_ttfx() {
    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="ttfx"
                ;;
            ttfx,beams)
                cmd="ttfx__subcmd__beams"
                ;;
            ttfx,binarypath)
                cmd="ttfx__subcmd__binarypath"
                ;;
            ttfx,blackhole)
                cmd="ttfx__subcmd__blackhole"
                ;;
            ttfx,bouncyballs)
                cmd="ttfx__subcmd__bouncyballs"
                ;;
            ttfx,bubbles)
                cmd="ttfx__subcmd__bubbles"
                ;;
            ttfx,burn)
                cmd="ttfx__subcmd__burn"
                ;;
            ttfx,colorshift)
                cmd="ttfx__subcmd__colorshift"
                ;;
            ttfx,crumble)
                cmd="ttfx__subcmd__crumble"
                ;;
            ttfx,decrypt)
                cmd="ttfx__subcmd__decrypt"
                ;;
            ttfx,errorcorrect)
                cmd="ttfx__subcmd__errorcorrect"
                ;;
            ttfx,expand)
                cmd="ttfx__subcmd__expand"
                ;;
            ttfx,fireworks)
                cmd="ttfx__subcmd__fireworks"
                ;;
            ttfx,help)
                cmd="ttfx__subcmd__help"
                ;;
            ttfx,highlight)
                cmd="ttfx__subcmd__highlight"
                ;;
            ttfx,laseretch)
                cmd="ttfx__subcmd__laseretch"
                ;;
            ttfx,matrix)
                cmd="ttfx__subcmd__matrix"
                ;;
            ttfx,middleout)
                cmd="ttfx__subcmd__middleout"
                ;;
            ttfx,orbittingvolley)
                cmd="ttfx__subcmd__orbittingvolley"
                ;;
            ttfx,overflow)
                cmd="ttfx__subcmd__overflow"
                ;;
            ttfx,pour)
                cmd="ttfx__subcmd__pour"
                ;;
            ttfx,print)
                cmd="ttfx__subcmd__print"
                ;;
            ttfx,rain)
                cmd="ttfx__subcmd__rain"
                ;;
            ttfx,randomsequence)
                cmd="ttfx__subcmd__randomsequence"
                ;;
            ttfx,rings)
                cmd="ttfx__subcmd__rings"
                ;;
            ttfx,scattered)
                cmd="ttfx__subcmd__scattered"
                ;;
            ttfx,slice)
                cmd="ttfx__subcmd__slice"
                ;;
            ttfx,slide)
                cmd="ttfx__subcmd__slide"
                ;;
            ttfx,smoke)
                cmd="ttfx__subcmd__smoke"
                ;;
            ttfx,spotlights)
                cmd="ttfx__subcmd__spotlights"
                ;;
            ttfx,spray)
                cmd="ttfx__subcmd__spray"
                ;;
            ttfx,swarm)
                cmd="ttfx__subcmd__swarm"
                ;;
            ttfx,sweep)
                cmd="ttfx__subcmd__sweep"
                ;;
            ttfx,synthgrid)
                cmd="ttfx__subcmd__synthgrid"
                ;;
            ttfx,thunderstorm)
                cmd="ttfx__subcmd__thunderstorm"
                ;;
            ttfx,unstable)
                cmd="ttfx__subcmd__unstable"
                ;;
            ttfx,vhstape)
                cmd="ttfx__subcmd__vhstape"
                ;;
            ttfx,waves)
                cmd="ttfx__subcmd__waves"
                ;;
            ttfx,wipe)
                cmd="ttfx__subcmd__wipe"
                ;;
            ttfx__subcmd__help,beams)
                cmd="ttfx__subcmd__help__subcmd__beams"
                ;;
            ttfx__subcmd__help,binarypath)
                cmd="ttfx__subcmd__help__subcmd__binarypath"
                ;;
            ttfx__subcmd__help,blackhole)
                cmd="ttfx__subcmd__help__subcmd__blackhole"
                ;;
            ttfx__subcmd__help,bouncyballs)
                cmd="ttfx__subcmd__help__subcmd__bouncyballs"
                ;;
            ttfx__subcmd__help,bubbles)
                cmd="ttfx__subcmd__help__subcmd__bubbles"
                ;;
            ttfx__subcmd__help,burn)
                cmd="ttfx__subcmd__help__subcmd__burn"
                ;;
            ttfx__subcmd__help,colorshift)
                cmd="ttfx__subcmd__help__subcmd__colorshift"
                ;;
            ttfx__subcmd__help,crumble)
                cmd="ttfx__subcmd__help__subcmd__crumble"
                ;;
            ttfx__subcmd__help,decrypt)
                cmd="ttfx__subcmd__help__subcmd__decrypt"
                ;;
            ttfx__subcmd__help,errorcorrect)
                cmd="ttfx__subcmd__help__subcmd__errorcorrect"
                ;;
            ttfx__subcmd__help,expand)
                cmd="ttfx__subcmd__help__subcmd__expand"
                ;;
            ttfx__subcmd__help,fireworks)
                cmd="ttfx__subcmd__help__subcmd__fireworks"
                ;;
            ttfx__subcmd__help,help)
                cmd="ttfx__subcmd__help__subcmd__help"
                ;;
            ttfx__subcmd__help,highlight)
                cmd="ttfx__subcmd__help__subcmd__highlight"
                ;;
            ttfx__subcmd__help,laseretch)
                cmd="ttfx__subcmd__help__subcmd__laseretch"
                ;;
            ttfx__subcmd__help,matrix)
                cmd="ttfx__subcmd__help__subcmd__matrix"
                ;;
            ttfx__subcmd__help,middleout)
                cmd="ttfx__subcmd__help__subcmd__middleout"
                ;;
            ttfx__subcmd__help,orbittingvolley)
                cmd="ttfx__subcmd__help__subcmd__orbittingvolley"
                ;;
            ttfx__subcmd__help,overflow)
                cmd="ttfx__subcmd__help__subcmd__overflow"
                ;;
            ttfx__subcmd__help,pour)
                cmd="ttfx__subcmd__help__subcmd__pour"
                ;;
            ttfx__subcmd__help,print)
                cmd="ttfx__subcmd__help__subcmd__print"
                ;;
            ttfx__subcmd__help,rain)
                cmd="ttfx__subcmd__help__subcmd__rain"
                ;;
            ttfx__subcmd__help,randomsequence)
                cmd="ttfx__subcmd__help__subcmd__randomsequence"
                ;;
            ttfx__subcmd__help,rings)
                cmd="ttfx__subcmd__help__subcmd__rings"
                ;;
            ttfx__subcmd__help,scattered)
                cmd="ttfx__subcmd__help__subcmd__scattered"
                ;;
            ttfx__subcmd__help,slice)
                cmd="ttfx__subcmd__help__subcmd__slice"
                ;;
            ttfx__subcmd__help,slide)
                cmd="ttfx__subcmd__help__subcmd__slide"
                ;;
            ttfx__subcmd__help,smoke)
                cmd="ttfx__subcmd__help__subcmd__smoke"
                ;;
            ttfx__subcmd__help,spotlights)
                cmd="ttfx__subcmd__help__subcmd__spotlights"
                ;;
            ttfx__subcmd__help,spray)
                cmd="ttfx__subcmd__help__subcmd__spray"
                ;;
            ttfx__subcmd__help,swarm)
                cmd="ttfx__subcmd__help__subcmd__swarm"
                ;;
            ttfx__subcmd__help,sweep)
                cmd="ttfx__subcmd__help__subcmd__sweep"
                ;;
            ttfx__subcmd__help,synthgrid)
                cmd="ttfx__subcmd__help__subcmd__synthgrid"
                ;;
            ttfx__subcmd__help,thunderstorm)
                cmd="ttfx__subcmd__help__subcmd__thunderstorm"
                ;;
            ttfx__subcmd__help,unstable)
                cmd="ttfx__subcmd__help__subcmd__unstable"
                ;;
            ttfx__subcmd__help,vhstape)
                cmd="ttfx__subcmd__help__subcmd__vhstape"
                ;;
            ttfx__subcmd__help,waves)
                cmd="ttfx__subcmd__help__subcmd__waves"
                ;;
            ttfx__subcmd__help,wipe)
                cmd="ttfx__subcmd__help__subcmd__wipe"
                ;;
            *)
                ;;
        esac
    done

    case "${cmd}" in
        ttfx)
            opts="-v -i -R -h --version --input-file --tab-width --xterm-colors --no-color --terminal-background-color --existing-color-handling --wrap-text --frame-rate --canvas-width --canvas-height --anchor-canvas --anchor-text --ignore-terminal-dimensions --reuse-canvas --no-eol --no-restore-cursor --seed --print-completion --random-effect --include-effects --exclude-effects --m0-dump --parity-dump --max-frames --virtual-clock --help beams binarypath blackhole bouncyballs bubbles burn colorshift crumble decrypt errorcorrect expand fireworks highlight laseretch matrix middleout orbittingvolley overflow pour print rain randomsequence rings scattered slice slide smoke spotlights spray swarm sweep synthgrid thunderstorm unstable vhstape waves wipe help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --input-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -i)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --tab-width)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --terminal-background-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --existing-color-handling)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --frame-rate)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --canvas-width)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --canvas-height)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --anchor-canvas)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --anchor-text)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --seed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --print-completion)
                    COMPREPLY=($(compgen -W "bash zsh" -- "${cur}"))
                    return 0
                    ;;
                --include-effects)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exclude-effects)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__beams)
            opts="-h --beam-row-symbols --beam-column-symbols --beam-delay --beam-row-speed-range --beam-column-speed-range --beam-gradient-stops --beam-gradient-steps --beam-gradient-frames --final-gradient-stops --final-gradient-steps --final-gradient-frames --final-gradient-direction --final-wipe-speed --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --beam-row-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --beam-column-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --beam-delay)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --beam-row-speed-range)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --beam-column-speed-range)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --beam-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --beam-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --beam-gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-wipe-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__binarypath)
            opts="-h --final-gradient-stops --final-gradient-steps --final-gradient-direction --binary-colors --movement-speed --active-binary-groups --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --binary-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --active-binary-groups)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__blackhole)
            opts="-h --blackhole-color --star-colors --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --blackhole-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --star-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__bouncyballs)
            opts="-h --ball-colors --ball-symbols --ball-delay --movement-speed --movement-easing --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --ball-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --ball-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --ball-delay)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__bubbles)
            opts="-h --rainbow --bubble-colors --pop-color --bubble-speed --bubble-delay --pop-condition --movement-easing --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --bubble-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --pop-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --bubble-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --bubble-delay)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --pop-condition)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__burn)
            opts="-h --starting-color --burn-colors --smoke-chance --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --starting-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --burn-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --smoke-chance)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__colorshift)
            opts="-h --gradient-stops --gradient-steps --gradient-frames --no-travel --travel-direction --reverse-travel-direction --no-loop --cycles --skip-final-gradient --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --travel-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cycles)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__crumble)
            opts="-h --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__decrypt)
            opts="-h --typing-speed --ciphertext-colors --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --typing-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --ciphertext-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__errorcorrect)
            opts="-h --error-pairs --swap-delay --error-color --correct-color --movement-speed --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --error-pairs)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --swap-delay)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --error-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --correct-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__expand)
            opts="-h --expand-easing --movement-speed --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --expand-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__fireworks)
            opts="-h --explode-anywhere --firework-colors --firework-symbol --firework-volume --launch-delay --explode-distance --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --firework-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --firework-symbol)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --firework-volume)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --launch-delay)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --explode-distance)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__help)
            opts="beams binarypath blackhole bouncyballs bubbles burn colorshift crumble decrypt errorcorrect expand fireworks highlight laseretch matrix middleout orbittingvolley overflow pour print rain randomsequence rings scattered slice slide smoke spotlights spray swarm sweep synthgrid thunderstorm unstable vhstape waves wipe 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
            ;;
        ttfx__subcmd__help__subcmd__beams)
            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
            ;;
        ttfx__subcmd__help__subcmd__binarypath)
            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
            ;;
        ttfx__subcmd__help__subcmd__blackhole)
            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
            ;;
        ttfx__subcmd__help__subcmd__bouncyballs)
            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
            ;;
        ttfx__subcmd__help__subcmd__bubbles)
            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
            ;;
        ttfx__subcmd__help__subcmd__burn)
            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
            ;;
        ttfx__subcmd__help__subcmd__colorshift)
            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
            ;;
        ttfx__subcmd__help__subcmd__crumble)
            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
            ;;
        ttfx__subcmd__help__subcmd__decrypt)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__help__subcmd__errorcorrect)
            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
            ;;
        ttfx__subcmd__help__subcmd__expand)
            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
            ;;
        ttfx__subcmd__help__subcmd__fireworks)
            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
            ;;
        ttfx__subcmd__help__subcmd__help)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__help__subcmd__highlight)
            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
            ;;
        ttfx__subcmd__help__subcmd__laseretch)
            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
            ;;
        ttfx__subcmd__help__subcmd__matrix)
            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
            ;;
        ttfx__subcmd__help__subcmd__middleout)
            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
            ;;
        ttfx__subcmd__help__subcmd__orbittingvolley)
            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
            ;;
        ttfx__subcmd__help__subcmd__overflow)
            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
            ;;
        ttfx__subcmd__help__subcmd__pour)
            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
            ;;
        ttfx__subcmd__help__subcmd__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
            ;;
        ttfx__subcmd__help__subcmd__rain)
            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
            ;;
        ttfx__subcmd__help__subcmd__randomsequence)
            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
            ;;
        ttfx__subcmd__help__subcmd__rings)
            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
            ;;
        ttfx__subcmd__help__subcmd__scattered)
            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
            ;;
        ttfx__subcmd__help__subcmd__slice)
            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
            ;;
        ttfx__subcmd__help__subcmd__slide)
            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
            ;;
        ttfx__subcmd__help__subcmd__smoke)
            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
            ;;
        ttfx__subcmd__help__subcmd__spotlights)
            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
            ;;
        ttfx__subcmd__help__subcmd__spray)
            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
            ;;
        ttfx__subcmd__help__subcmd__swarm)
            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
            ;;
        ttfx__subcmd__help__subcmd__sweep)
            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
            ;;
        ttfx__subcmd__help__subcmd__synthgrid)
            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
            ;;
        ttfx__subcmd__help__subcmd__thunderstorm)
            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
            ;;
        ttfx__subcmd__help__subcmd__unstable)
            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
            ;;
        ttfx__subcmd__help__subcmd__vhstape)
            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
            ;;
        ttfx__subcmd__help__subcmd__waves)
            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
            ;;
        ttfx__subcmd__help__subcmd__wipe)
            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
            ;;
        ttfx__subcmd__highlight)
            opts="-h --highlight-brightness --highlight-direction --highlight-width --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --highlight-brightness)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --highlight-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --highlight-width)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__laseretch)
            opts="-h --etch-pattern --etch-speed --etch-delay --cool-gradient-stops --laser-gradient-stops --spark-gradient-stops --spark-cooling-frames --final-gradient-stops --final-gradient-steps --final-gradient-frames --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --etch-pattern)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --etch-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --etch-delay)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cool-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --laser-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --spark-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --spark-cooling-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__matrix)
            opts="-h --highlight-color --rain-color-gradient --rain-symbols --rain-fall-delay-range --rain-column-delay-range --rain-time --symbol-swap-chance --color-swap-chance --resolve-delay --final-gradient-stops --final-gradient-steps --final-gradient-frames --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --highlight-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --rain-color-gradient)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --rain-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --rain-fall-delay-range)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --rain-column-delay-range)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --rain-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --symbol-swap-chance)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color-swap-chance)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --resolve-delay)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__middleout)
            opts="-h --starting-color --expand-direction --center-movement-speed --full-movement-speed --center-easing --full-easing --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --starting-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --expand-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --center-movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --full-movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --center-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --full-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__orbittingvolley)
            opts="-h --top-launcher-symbol --right-launcher-symbol --bottom-launcher-symbol --left-launcher-symbol --launcher-movement-speed --character-movement-speed --volley-size --launch-delay --character-easing --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --top-launcher-symbol)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --right-launcher-symbol)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --bottom-launcher-symbol)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --left-launcher-symbol)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --launcher-movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --character-movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --volley-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --launch-delay)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --character-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__overflow)
            opts="-h --overflow-gradient-stops --overflow-cycles-range --overflow-speed --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --overflow-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --overflow-cycles-range)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --overflow-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__pour)
            opts="-h --pour-direction --pour-speed --movement-speed-range --gap --starting-color --final-gradient-stops --final-gradient-steps --final-gradient-frames --final-gradient-direction --movement-easing --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --pour-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --pour-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-speed-range)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gap)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --starting-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__print)
            opts="-h --print-head-return-speed --print-speed --print-head-easing --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --print-head-return-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --print-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --print-head-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__rain)
            opts="-h --rain-colors --movement-speed --rain-symbols --final-gradient-stops --final-gradient-steps --final-gradient-direction --movement-easing --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --rain-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --rain-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__randomsequence)
            opts="-h --speed --final-gradient-stops --final-gradient-steps --final-gradient-frames --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__rings)
            opts="-h --ring-colors --ring-gap --spin-duration --spin-speed --disperse-duration --spin-disperse-cycles --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --ring-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --ring-gap)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --spin-duration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --spin-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --disperse-duration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --spin-disperse-cycles)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__scattered)
            opts="-h --movement-speed --movement-easing --final-gradient-stops --final-gradient-steps --final-gradient-frames --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__slice)
            opts="-h --slice-direction --movement-speed --movement-easing --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --slice-direction)
                    COMPREPLY=($(compgen -W "vertical horizontal diagonal" -- "${cur}"))
                    return 0
                    ;;
                --movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__slide)
            opts="-h --movement-speed --grouping --gap --reverse-direction --merge --movement-easing --final-gradient-stops --final-gradient-steps --final-gradient-frames --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --movement-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --grouping)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gap)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__smoke)
            opts="-h --starting-color --smoke-symbols --smoke-gradient-stops --use-whole-canvas --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --starting-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --smoke-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --smoke-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__spotlights)
            opts="-h --beam-width-ratio --beam-falloff --search-duration --search-speed-range --spotlight-count --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --beam-width-ratio)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --beam-falloff)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --search-duration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --search-speed-range)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --spotlight-count)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__spray)
            opts="-h --spray-position --spray-volume --movement-speed-range --movement-easing --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --spray-position)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --spray-volume)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-speed-range)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --movement-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__swarm)
            opts="-h --base-color --flash-color --swarm-size --swarm-coordination --swarm-area-count-range --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --base-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --flash-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --swarm-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --swarm-coordination)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --swarm-area-count-range)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__sweep)
            opts="-h --sweep-symbols --first-sweep-direction --second-sweep-direction --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --sweep-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --first-sweep-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --second-sweep-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__synthgrid)
            opts="-h --grid-gradient-stops --grid-gradient-steps --grid-gradient-direction --text-gradient-stops --text-gradient-steps --text-gradient-direction --grid-row-symbol --grid-column-symbol --text-generation-symbols --max-active-blocks --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --grid-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --grid-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --grid-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --text-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --text-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --text-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --grid-row-symbol)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --grid-column-symbol)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --text-generation-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-active-blocks)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__thunderstorm)
            opts="-h --lightning-color --glowing-text-color --text-glow-time --raindrop-symbols --spark-symbols --spark-glow-color --spark-glow-time --storm-time --final-gradient-stops --final-gradient-steps --final-gradient-frames --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --lightning-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glowing-text-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --text-glow-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --raindrop-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --spark-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --spark-glow-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --spark-glow-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --storm-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__unstable)
            opts="-h --unstable-color --explosion-ease --explosion-speed --reassembly-ease --reassembly-speed --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --unstable-color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --explosion-ease)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --explosion-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reassembly-ease)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reassembly-speed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__vhstape)
            opts="-h --glitch-line-colors --glitch-wave-colors --noise-colors --glitch-line-chance --noise-chance --total-glitch-time --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --glitch-line-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glitch-wave-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --noise-colors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glitch-line-chance)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --noise-chance)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --total-glitch-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__waves)
            opts="-h --wave-symbols --wave-gradient-stops --wave-gradient-steps --wave-count --wave-length --wave-direction --wave-easing --final-gradient-stops --final-gradient-steps --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --wave-symbols)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --wave-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --wave-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --wave-count)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --wave-length)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --wave-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --wave-easing)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        ttfx__subcmd__wipe)
            opts="-h --wipe-direction --wipe-delay --wipe-ease --final-gradient-stops --final-gradient-steps --final-gradient-frames --final-gradient-direction --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --wipe-direction)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --wipe-delay)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --wipe-ease)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-stops)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-frames)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --final-gradient-direction)
                    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 _ttfx -o nosort -o bashdefault -o default ttfx
else
    complete -F _ttfx -o bashdefault -o default ttfx
fi
