#----------------------------------*-sh-*--------------------------------------
# Bash completions for OpenFOAM applications

unset -f _of_filter_opts 2>/dev/null
_of_filter_opts()
{
    local allOpts=$1
    local applied=$2
    for o in ${allOpts}; do
        [ "${applied/$o/}" == "${applied}" ] && echo $o
    done
}

unset -f _of_adiabaticFlameT 2>/dev/null
_of_adiabaticFlameT()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_adiabaticFlameT adiabaticFlameT

unset -f _of_adjointShapeOptimizationFoam 2>/dev/null
_of_adjointShapeOptimizationFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_adjointShapeOptimizationFoam adjointShapeOptimizationFoam

unset -f _of_ansysToFoam 2>/dev/null
_of_ansysToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_ansysToFoam ansysToFoam

unset -f _of_applyBoundaryLayer 2>/dev/null
_of_applyBoundaryLayer()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots -ybl "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_applyBoundaryLayer applyBoundaryLayer

unset -f _of_attachMesh 2>/dev/null
_of_attachMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_attachMesh attachMesh

unset -f _of_autoPatch 2>/dev/null
_of_autoPatch()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_autoPatch autoPatch

unset -f _of_blockMesh 2>/dev/null
_of_blockMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-blockTopology -noClean -noFunctionObjects -sets -srcDoc -doc -help "
    local optsWithArgs="-case -dict -region "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_blockMesh blockMesh

unset -f _of_boundaryFoam 2>/dev/null
_of_boundaryFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_boundaryFoam boundaryFoam

unset -f _of_boxTurb 2>/dev/null
_of_boxTurb()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_boxTurb boxTurb

unset -f _of_buoyantBoussinesqPimpleFoam 2>/dev/null
_of_buoyantBoussinesqPimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_buoyantBoussinesqPimpleFoam buoyantBoussinesqPimpleFoam

unset -f _of_buoyantBoussinesqSimpleFoam 2>/dev/null
_of_buoyantBoussinesqSimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_buoyantBoussinesqSimpleFoam buoyantBoussinesqSimpleFoam

unset -f _of_buoyantPimpleFoam 2>/dev/null
_of_buoyantPimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_buoyantPimpleFoam buoyantPimpleFoam

unset -f _of_buoyantSimpleFoam 2>/dev/null
_of_buoyantSimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_buoyantSimpleFoam buoyantSimpleFoam

unset -f _of_cavitatingDyMFoam 2>/dev/null
_of_cavitatingDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_cavitatingDyMFoam cavitatingDyMFoam

unset -f _of_cavitatingFoam 2>/dev/null
_of_cavitatingFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_cavitatingFoam cavitatingFoam

unset -f _of_cfx4ToFoam 2>/dev/null
_of_cfx4ToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_cfx4ToFoam cfx4ToFoam

unset -f _of_changeDictionary 2>/dev/null
_of_changeDictionary()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -disablePatchGroups -enableFunctionEntries -latestTime -literalRE -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -instance -region -roots -subDict -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_changeDictionary changeDictionary

unset -f _of_checkMesh 2>/dev/null
_of_checkMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-allGeometry -allTopology -constant -latestTime -meshQuality -newTimes -noFunctionObjects -noTopology -noZero -parallel -writeAllFields -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots -time -writeFields -writeSets "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_checkMesh checkMesh

unset -f _of_chemFoam 2>/dev/null
_of_chemFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_chemFoam chemFoam

unset -f _of_chemkinToFoam 2>/dev/null
_of_chemkinToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-newFormat -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_chemkinToFoam chemkinToFoam

unset -f _of_chtMultiRegionFoam 2>/dev/null
_of_chtMultiRegionFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_chtMultiRegionFoam chtMultiRegionFoam

unset -f _of_chtMultiRegionSimpleFoam 2>/dev/null
_of_chtMultiRegionSimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_chtMultiRegionSimpleFoam chtMultiRegionSimpleFoam

unset -f _of_coalChemistryFoam 2>/dev/null
_of_coalChemistryFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_coalChemistryFoam coalChemistryFoam

unset -f _of_coldEngineFoam 2>/dev/null
_of_coldEngineFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_coldEngineFoam coldEngineFoam

unset -f _of_collapseEdges 2>/dev/null
_of_collapseEdges()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-collapseFaces -constant -latestTime -newTimes -noFunctionObjects -noZero -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -collapseFaceSet -decomposeParDict -dict -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_collapseEdges collapseEdges

unset -f _of_combinePatchFaces 2>/dev/null
_of_combinePatchFaces()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-meshQuality -noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -concaveAngle -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_combinePatchFaces combinePatchFaces

unset -f _of_compressibleInterDyMFoam 2>/dev/null
_of_compressibleInterDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_compressibleInterDyMFoam compressibleInterDyMFoam

unset -f _of_compressibleInterFoam 2>/dev/null
_of_compressibleInterFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_compressibleInterFoam compressibleInterFoam

unset -f _of_compressibleMultiphaseInterFoam 2>/dev/null
_of_compressibleMultiphaseInterFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_compressibleMultiphaseInterFoam compressibleMultiphaseInterFoam

unset -f _of_createBaffles 2>/dev/null
_of_createBaffles()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_createBaffles createBaffles

unset -f _of_createExternalCoupledPatchGeometry 2>/dev/null
_of_createExternalCoupledPatchGeometry()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -commsDir -decomposeParDict -region -regions -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_createExternalCoupledPatchGeometry createExternalCoupledPatchGeometry

unset -f _of_createPatch 2>/dev/null
_of_createPatch()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -writeObj -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_createPatch createPatch

unset -f _of_createZeroDirectory 2>/dev/null
_of_createZeroDirectory()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots -templateDir "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_createZeroDirectory createZeroDirectory

unset -f _of_datToFoam 2>/dev/null
_of_datToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_datToFoam datToFoam

unset -f _of_decomposePar 2>/dev/null
_of_decomposePar()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-allRegions -cellDist -constant -copyUniform -copyZero -fields -force -ifRequired -latestTime -newTimes -noFunctionObjects -noSets -noZero -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_decomposePar decomposePar

unset -f _of_deformedGeom 2>/dev/null
_of_deformedGeom()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_deformedGeom deformedGeom

unset -f _of_dnsFoam 2>/dev/null
_of_dnsFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_dnsFoam dnsFoam

unset -f _of_DPMDyMFoam 2>/dev/null
_of_DPMDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -cloudName -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_DPMDyMFoam DPMDyMFoam

unset -f _of_DPMFoam 2>/dev/null
_of_DPMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -cloud -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_DPMFoam DPMFoam

unset -f _of_driftFluxFoam 2>/dev/null
_of_driftFluxFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_driftFluxFoam driftFluxFoam

unset -f _of_dsmcFoam 2>/dev/null
_of_dsmcFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_dsmcFoam dsmcFoam

unset -f _of_dsmcInitialise 2>/dev/null
_of_dsmcInitialise()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_dsmcInitialise dsmcInitialise

unset -f _of_electrostaticFoam 2>/dev/null
_of_electrostaticFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_electrostaticFoam electrostaticFoam

unset -f _of_engineCompRatio 2>/dev/null
_of_engineCompRatio()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_engineCompRatio engineCompRatio

unset -f _of_engineFoam 2>/dev/null
_of_engineFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_engineFoam engineFoam

unset -f _of_engineSwirl 2>/dev/null
_of_engineSwirl()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_engineSwirl engineSwirl

unset -f _of_equilibriumCO 2>/dev/null
_of_equilibriumCO()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_equilibriumCO equilibriumCO

unset -f _of_equilibriumFlameT 2>/dev/null
_of_equilibriumFlameT()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_equilibriumFlameT equilibriumFlameT

unset -f _of_extrude2DMesh 2>/dev/null
_of_extrude2DMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_extrude2DMesh extrude2DMesh

unset -f _of_extrudeMesh 2>/dev/null
_of_extrudeMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_extrudeMesh extrudeMesh

unset -f _of_extrudeToRegionMesh 2>/dev/null
_of_extrudeToRegionMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_extrudeToRegionMesh extrudeToRegionMesh

unset -f _of_faceAgglomerate 2>/dev/null
_of_faceAgglomerate()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_faceAgglomerate faceAgglomerate

unset -f _of_financialFoam 2>/dev/null
_of_financialFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_financialFoam financialFoam

unset -f _of_fireFoam 2>/dev/null
_of_fireFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_fireFoam fireFoam

unset -f _of_fireToFoam 2>/dev/null
_of_fireToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-ascii -check -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_fireToFoam fireToFoam

unset -f _of_flattenMesh 2>/dev/null
_of_flattenMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_flattenMesh flattenMesh

unset -f _of_fluent3DMeshToFoam 2>/dev/null
_of_fluent3DMeshToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-cubit -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -ignoreCellGroups -ignoreFaceGroups -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_fluent3DMeshToFoam fluent3DMeshToFoam

unset -f _of_fluentMeshToFoam 2>/dev/null
_of_fluentMeshToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -writeSets -writeZones -srcDoc -doc -help "
    local optsWithArgs="-case -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_fluentMeshToFoam fluentMeshToFoam

unset -f _of_foamDataToFluent 2>/dev/null
_of_foamDataToFluent()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help "
    local optsWithArgs="-case -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamDataToFluent foamDataToFluent

unset -f _of_foamDictionary 2>/dev/null
_of_foamDictionary()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-disableFunctionEntries -expand -includes -keywords -noFunctionObjects -parallel -remove -value -srcDoc -doc -help "
    local optsWithArgs="-add -case -decomposeParDict -diff -entry -roots -set "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamDictionary foamDictionary

unset -f _of_foamFormatConvert 2>/dev/null
_of_foamFormatConvert()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -enableFunctionEntries -latestTime -newTimes -noConstant -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamFormatConvert foamFormatConvert

unset -f _of_foamHelp 2>/dev/null
_of_foamHelp()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamHelp foamHelp

unset -f _of_foamList 2>/dev/null
_of_foamList()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-compressibleTurbulenceModels -functionObjects -fvOptions -incompressibleTurbulenceModels -noFunctionObjects -registeredSwitches -switches -unset -srcDoc -doc -help "
    local optsWithArgs="-case -scalarBCs -vectorBCs "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamList foamList

unset -f _of_foamListTimes 2>/dev/null
_of_foamListTimes()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -processor -rm -withZero -srcDoc -doc -help "
    local optsWithArgs="-case -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamListTimes foamListTimes

unset -f _of_foamMeshToFluent 2>/dev/null
_of_foamMeshToFluent()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamMeshToFluent foamMeshToFluent

unset -f _of_foamToEnsight 2>/dev/null
_of_foamToEnsight()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-ascii -constant -deprecatedOrder -latestTime -newTimes -noFunctionObjects -noLagrangian -noPatches -noZero -nodeValues -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -cellZone -decomposeParDict -faceZones -fields -name -patches -region -roots -time -width "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamToEnsight foamToEnsight

unset -f _of_foamToEnsightParts 2>/dev/null
_of_foamToEnsightParts()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-ascii -constant -latestTime -newTimes -noFunctionObjects -noLagrangian -noMesh -noZero -srcDoc -doc -help "
    local optsWithArgs="-case -index -name -time -width "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamToEnsightParts foamToEnsightParts

unset -f _of_foamToFireMesh 2>/dev/null
_of_foamToFireMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-ascii -constant -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help "
    local optsWithArgs="-case -scale -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamToFireMesh foamToFireMesh

unset -f _of_foamToGMV 2>/dev/null
_of_foamToGMV()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamToGMV foamToGMV

unset -f _of_foamToStarMesh 2>/dev/null
_of_foamToStarMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noBnd -noFunctionObjects -noZero -srcDoc -doc -help "
    local optsWithArgs="-case -scale -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamToStarMesh foamToStarMesh

unset -f _of_foamToSurface 2>/dev/null
_of_foamToSurface()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -tri -srcDoc -doc -help "
    local optsWithArgs="-case -scale -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamToSurface foamToSurface

unset -f _of_foamToTetDualMesh 2>/dev/null
_of_foamToTetDualMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -noFunctionObjects -noZero -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamToTetDualMesh foamToTetDualMesh

unset -f _of_foamToVTK 2>/dev/null
_of_foamToVTK()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-allPatches -ascii -constant -latestTime -nearCellValue -newTimes -noFaceZones -noFunctionObjects -noInternal -noLagrangian -noLinks -noPointValues -noZero -parallel -poly -surfaceFields -useTimeName -xml -srcDoc -doc -help "
    local optsWithArgs="-case -cellSet -decomposeParDict -excludePatches -faceSet -fields -name -pointSet -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamToVTK foamToVTK

unset -f _of_foamUpgradeCyclics 2>/dev/null
_of_foamUpgradeCyclics()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -enableFunctionEntries -latestTime -newTimes -noFunctionObjects -noZero -parallel -test -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamUpgradeCyclics foamUpgradeCyclics

unset -f _of_foamyHexMesh 2>/dev/null
_of_foamyHexMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-checkGeometry -conformationOnly -noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamyHexMesh foamyHexMesh

unset -f _of_foamyQuadMesh 2>/dev/null
_of_foamyQuadMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -srcDoc -doc -help "
    local optsWithArgs="-case -pointsFile "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_foamyQuadMesh foamyQuadMesh

unset -f _of_gambitToFoam 2>/dev/null
_of_gambitToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_gambitToFoam gambitToFoam

unset -f _of_gmshToFoam 2>/dev/null
_of_gmshToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-keepOrientation -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -region "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_gmshToFoam gmshToFoam

unset -f _of_icoFoam 2>/dev/null
_of_icoFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_icoFoam icoFoam

unset -f _of_icoUncoupledKinematicParcelDyMFoam 2>/dev/null
_of_icoUncoupledKinematicParcelDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -cloud -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_icoUncoupledKinematicParcelDyMFoam icoUncoupledKinematicParcelDyMFoam

unset -f _of_icoUncoupledKinematicParcelFoam 2>/dev/null
_of_icoUncoupledKinematicParcelFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -cloud -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_icoUncoupledKinematicParcelFoam icoUncoupledKinematicParcelFoam

unset -f _of_ideasUnvToFoam 2>/dev/null
_of_ideasUnvToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-dump -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_ideasUnvToFoam ideasUnvToFoam

unset -f _of_insideCells 2>/dev/null
_of_insideCells()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_insideCells insideCells

unset -f _of_interCondensatingEvaporatingFoam 2>/dev/null
_of_interCondensatingEvaporatingFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_interCondensatingEvaporatingFoam interCondensatingEvaporatingFoam

unset -f _of_interDyMFoam 2>/dev/null
_of_interDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_interDyMFoam interDyMFoam

unset -f _of_interFoam 2>/dev/null
_of_interFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_interFoam interFoam

unset -f _of_interMixingFoam 2>/dev/null
_of_interMixingFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_interMixingFoam interMixingFoam

unset -f _of_interPhaseChangeDyMFoam 2>/dev/null
_of_interPhaseChangeDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_interPhaseChangeDyMFoam interPhaseChangeDyMFoam

unset -f _of_interPhaseChangeFoam 2>/dev/null
_of_interPhaseChangeFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_interPhaseChangeFoam interPhaseChangeFoam

unset -f _of_kivaToFoam 2>/dev/null
_of_kivaToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -file -version -zHeadMin "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_kivaToFoam kivaToFoam

unset -f _of_laplacianFoam 2>/dev/null
_of_laplacianFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_laplacianFoam laplacianFoam

unset -f _of_magneticFoam 2>/dev/null
_of_magneticFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noB -noFunctionObjects -noH -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_magneticFoam magneticFoam

unset -f _of_mapFields 2>/dev/null
_of_mapFields()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-consistent -noFunctionObjects -parallelSource -parallelTarget -subtract -srcDoc -doc -help "
    local optsWithArgs="-case -mapMethod -sourceDecomposeParDict -sourceRegion -sourceTime -targetDecomposeParDict -targetRegion "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mapFields mapFields

unset -f _of_mapFieldsPar 2>/dev/null
_of_mapFieldsPar()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-consistent -noFunctionObjects -noLagrangian -parallel -subtract -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -fields -mapMethod -patchMapMethod -roots -sourceRegion -sourceTime -targetRegion "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mapFieldsPar mapFieldsPar

unset -f _of_mdEquilibrationFoam 2>/dev/null
_of_mdEquilibrationFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mdEquilibrationFoam mdEquilibrationFoam

unset -f _of_mdFoam 2>/dev/null
_of_mdFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mdFoam mdFoam

unset -f _of_mdInitialise 2>/dev/null
_of_mdInitialise()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mdInitialise mdInitialise

unset -f _of_mergeMeshes 2>/dev/null
_of_mergeMeshes()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-addRegion -case -decomposeParDict -masterRegion -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mergeMeshes mergeMeshes

unset -f _of_mergeOrSplitBaffles 2>/dev/null
_of_mergeOrSplitBaffles()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-detectOnly -noFunctionObjects -overwrite -parallel -split -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mergeOrSplitBaffles mergeOrSplitBaffles

unset -f _of_mhdFoam 2>/dev/null
_of_mhdFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mhdFoam mhdFoam

unset -f _of_mirrorMesh 2>/dev/null
_of_mirrorMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mirrorMesh mirrorMesh

unset -f _of_mixtureAdiabaticFlameT 2>/dev/null
_of_mixtureAdiabaticFlameT()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mixtureAdiabaticFlameT mixtureAdiabaticFlameT

unset -f _of_modifyMesh 2>/dev/null
_of_modifyMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_modifyMesh modifyMesh

unset -f _of_moveDynamicMesh 2>/dev/null
_of_moveDynamicMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-checkAMI -noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_moveDynamicMesh moveDynamicMesh

unset -f _of_moveEngineMesh 2>/dev/null
_of_moveEngineMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_moveEngineMesh moveEngineMesh

unset -f _of_moveMesh 2>/dev/null
_of_moveMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_moveMesh moveMesh

unset -f _of_MPPICDyMFoam 2>/dev/null
_of_MPPICDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -cloudName -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_MPPICDyMFoam MPPICDyMFoam

unset -f _of_MPPICFoam 2>/dev/null
_of_MPPICFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -cloud -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_MPPICFoam MPPICFoam

unset -f _of_MPPICInterFoam 2>/dev/null
_of_MPPICInterFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_MPPICInterFoam MPPICInterFoam

unset -f _of_mshToFoam 2>/dev/null
_of_mshToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-hex -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_mshToFoam mshToFoam

unset -f _of_multiphaseEulerFoam 2>/dev/null
_of_multiphaseEulerFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_multiphaseEulerFoam multiphaseEulerFoam

unset -f _of_multiphaseInterDyMFoam 2>/dev/null
_of_multiphaseInterDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_multiphaseInterDyMFoam multiphaseInterDyMFoam

unset -f _of_multiphaseInterFoam 2>/dev/null
_of_multiphaseInterFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_multiphaseInterFoam multiphaseInterFoam

unset -f _of_netgenNeutralToFoam 2>/dev/null
_of_netgenNeutralToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_netgenNeutralToFoam netgenNeutralToFoam

unset -f _of_noise 2>/dev/null
_of_noise()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_noise noise

unset -f _of_nonNewtonianIcoFoam 2>/dev/null
_of_nonNewtonianIcoFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_nonNewtonianIcoFoam nonNewtonianIcoFoam

unset -f _of_objToVTK 2>/dev/null
_of_objToVTK()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_objToVTK objToVTK

unset -f _of_orientFaceZone 2>/dev/null
_of_orientFaceZone()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_orientFaceZone orientFaceZone

unset -f _of_particleTracks 2>/dev/null
_of_particleTracks()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_particleTracks particleTracks

unset -f _of_patchSummary 2>/dev/null
_of_patchSummary()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -expand -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_patchSummary patchSummary

unset -f _of_pdfPlot 2>/dev/null
_of_pdfPlot()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_pdfPlot pdfPlot

unset -f _of_PDRFoam 2>/dev/null
_of_PDRFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_PDRFoam PDRFoam

unset -f _of_PDRMesh 2>/dev/null
_of_PDRMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_PDRMesh PDRMesh

unset -f _of_pimpleDyMFoam 2>/dev/null
_of_pimpleDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_pimpleDyMFoam pimpleDyMFoam

unset -f _of_pimpleFoam 2>/dev/null
_of_pimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_pimpleFoam pimpleFoam

unset -f _of_pisoFoam 2>/dev/null
_of_pisoFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_pisoFoam pisoFoam

unset -f _of_plot3dToFoam 2>/dev/null
_of_plot3dToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noBlank -noFunctionObjects -singleBlock -srcDoc -doc -help "
    local optsWithArgs="-case -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_plot3dToFoam plot3dToFoam

unset -f _of_polyDualMesh 2>/dev/null
_of_polyDualMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-concaveMultiCells -doNotPreserveFaceZones -noFunctionObjects -overwrite -splitAllFaces -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_polyDualMesh polyDualMesh

unset -f _of_porousSimpleFoam 2>/dev/null
_of_porousSimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_porousSimpleFoam porousSimpleFoam

unset -f _of_postChannel 2>/dev/null
_of_postChannel()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help "
    local optsWithArgs="-case -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_postChannel postChannel

unset -f _of_postProcess 2>/dev/null
_of_postProcess()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -list -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -field -fields -func -funcs -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_postProcess postProcess

unset -f _of_potentialFoam 2>/dev/null
_of_potentialFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-initialiseUBCs -noFunctionObjects -parallel -withFunctionObjects -writePhi -writep -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -pName -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_potentialFoam potentialFoam

unset -f _of_potentialFreeSurfaceDyMFoam 2>/dev/null
_of_potentialFreeSurfaceDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_potentialFreeSurfaceDyMFoam potentialFreeSurfaceDyMFoam

unset -f _of_potentialFreeSurfaceFoam 2>/dev/null
_of_potentialFreeSurfaceFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_potentialFreeSurfaceFoam potentialFreeSurfaceFoam

unset -f _of_reactingFoam 2>/dev/null
_of_reactingFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_reactingFoam reactingFoam

unset -f _of_reactingMultiphaseEulerFoam 2>/dev/null
_of_reactingMultiphaseEulerFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_reactingMultiphaseEulerFoam reactingMultiphaseEulerFoam

unset -f _of_reactingParcelFilmFoam 2>/dev/null
_of_reactingParcelFilmFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_reactingParcelFilmFoam reactingParcelFilmFoam

unset -f _of_reactingParcelFoam 2>/dev/null
_of_reactingParcelFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_reactingParcelFoam reactingParcelFoam

unset -f _of_reactingTwoPhaseEulerFoam 2>/dev/null
_of_reactingTwoPhaseEulerFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_reactingTwoPhaseEulerFoam reactingTwoPhaseEulerFoam

unset -f _of_reconstructPar 2>/dev/null
_of_reconstructPar()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-allRegions -constant -latestTime -newTimes -noFields -noFunctionObjects -noLagrangian -noSets -noZero -withZero -srcDoc -doc -help "
    local optsWithArgs="-case -fields -lagrangianFields -region -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_reconstructPar reconstructPar

unset -f _of_reconstructParMesh 2>/dev/null
_of_reconstructParMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-cellDist -constant -fullMatch -latestTime -newTimes -noFunctionObjects -noZero -withZero -srcDoc -doc -help "
    local optsWithArgs="-case -mergeTol -region -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_reconstructParMesh reconstructParMesh

unset -f _of_redistributePar 2>/dev/null
_of_redistributePar()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-cellDist -constant -decompose -latestTime -newTimes -noFunctionObjects -noZero -overwrite -parallel -reconstruct -withZero -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -mergeTol -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_redistributePar redistributePar

unset -f _of_refineHexMesh 2>/dev/null
_of_refineHexMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-minSet -noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_refineHexMesh refineHexMesh

unset -f _of_refinementLevel 2>/dev/null
_of_refinementLevel()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -readLevel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_refinementLevel refinementLevel

unset -f _of_refineMesh 2>/dev/null
_of_refineMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-all -noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_refineMesh refineMesh

unset -f _of_refineWallLayer 2>/dev/null
_of_refineWallLayer()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots -useSet "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_refineWallLayer refineWallLayer

unset -f _of_removeFaces 2>/dev/null
_of_removeFaces()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_removeFaces removeFaces

unset -f _of_renumberMesh 2>/dev/null
_of_renumberMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -frontWidth -latestTime -noFunctionObjects -noZero -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_renumberMesh renumberMesh

unset -f _of_rhoCentralDyMFoam 2>/dev/null
_of_rhoCentralDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_rhoCentralDyMFoam rhoCentralDyMFoam

unset -f _of_rhoCentralFoam 2>/dev/null
_of_rhoCentralFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_rhoCentralFoam rhoCentralFoam

unset -f _of_rhoPimpleDyMFoam 2>/dev/null
_of_rhoPimpleDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_rhoPimpleDyMFoam rhoPimpleDyMFoam

unset -f _of_rhoPimpleFoam 2>/dev/null
_of_rhoPimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_rhoPimpleFoam rhoPimpleFoam

unset -f _of_rhoPorousSimpleFoam 2>/dev/null
_of_rhoPorousSimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_rhoPorousSimpleFoam rhoPorousSimpleFoam

unset -f _of_rhoReactingBuoyantFoam 2>/dev/null
_of_rhoReactingBuoyantFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_rhoReactingBuoyantFoam rhoReactingBuoyantFoam

unset -f _of_rhoReactingFoam 2>/dev/null
_of_rhoReactingFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_rhoReactingFoam rhoReactingFoam

unset -f _of_rhoSimpleFoam 2>/dev/null
_of_rhoSimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_rhoSimpleFoam rhoSimpleFoam

unset -f _of_rotateMesh 2>/dev/null
_of_rotateMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_rotateMesh rotateMesh

unset -f _of_scalarTransportFoam 2>/dev/null
_of_scalarTransportFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_scalarTransportFoam scalarTransportFoam

unset -f _of_selectCells 2>/dev/null
_of_selectCells()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_selectCells selectCells

unset -f _of_setFields 2>/dev/null
_of_setFields()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_setFields setFields

unset -f _of_setSet 2>/dev/null
_of_setSet()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -loop -newTimes -noFunctionObjects -noSync -noVTK -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-batch -case -decomposeParDict -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_setSet setSet

unset -f _of_setsToZones 2>/dev/null
_of_setsToZones()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFlipMap -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_setsToZones setsToZones

unset -f _of_shallowWaterFoam 2>/dev/null
_of_shallowWaterFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_shallowWaterFoam shallowWaterFoam

unset -f _of_simpleCoalParcelFoam 2>/dev/null
_of_simpleCoalParcelFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_simpleCoalParcelFoam simpleCoalParcelFoam

unset -f _of_simpleFoam 2>/dev/null
_of_simpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_simpleFoam simpleFoam

unset -f _of_simpleReactingParcelFoam 2>/dev/null
_of_simpleReactingParcelFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_simpleReactingParcelFoam simpleReactingParcelFoam

unset -f _of_singleCellMesh 2>/dev/null
_of_singleCellMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_singleCellMesh singleCellMesh

unset -f _of_smapToFoam 2>/dev/null
_of_smapToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_smapToFoam smapToFoam

unset -f _of_snappyHexMesh 2>/dev/null
_of_snappyHexMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-checkGeometry -noFunctionObjects -overwrite -parallel -profiling -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -outFile -patches -region -roots -surfaceSimplify "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_snappyHexMesh snappyHexMesh

unset -f _of_snappyRefineMesh 2>/dev/null
_of_snappyRefineMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_snappyRefineMesh snappyRefineMesh

unset -f _of_solidDisplacementFoam 2>/dev/null
_of_solidDisplacementFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_solidDisplacementFoam solidDisplacementFoam

unset -f _of_solidEquilibriumDisplacementFoam 2>/dev/null
_of_solidEquilibriumDisplacementFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_solidEquilibriumDisplacementFoam solidEquilibriumDisplacementFoam

unset -f _of_sonicDyMFoam 2>/dev/null
_of_sonicDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_sonicDyMFoam sonicDyMFoam

unset -f _of_sonicFoam 2>/dev/null
_of_sonicFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_sonicFoam sonicFoam

unset -f _of_sonicLiquidFoam 2>/dev/null
_of_sonicLiquidFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_sonicLiquidFoam sonicLiquidFoam

unset -f _of_splitCells 2>/dev/null
_of_splitCells()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-geometry -noFunctionObjects -overwrite -srcDoc -doc -help "
    local optsWithArgs="-case -set -tol "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_splitCells splitCells

unset -f _of_splitMesh 2>/dev/null
_of_splitMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_splitMesh splitMesh

unset -f _of_splitMeshRegions 2>/dev/null
_of_splitMeshRegions()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-cellZones -cellZonesOnly -detectOnly -largestOnly -makeCellZones -noFunctionObjects -overwrite -parallel -prefixRegion -sloppyCellZones -useFaceZones -srcDoc -doc -help "
    local optsWithArgs="-blockedFaces -case -cellZonesFileOnly -decomposeParDict -insidePoint -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_splitMeshRegions splitMeshRegions

unset -f _of_sprayDyMFoam 2>/dev/null
_of_sprayDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_sprayDyMFoam sprayDyMFoam

unset -f _of_sprayEngineFoam 2>/dev/null
_of_sprayEngineFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_sprayEngineFoam sprayEngineFoam

unset -f _of_sprayFoam 2>/dev/null
_of_sprayFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_sprayFoam sprayFoam

unset -f _of_SRFPimpleFoam 2>/dev/null
_of_SRFPimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_SRFPimpleFoam SRFPimpleFoam

unset -f _of_SRFSimpleFoam 2>/dev/null
_of_SRFSimpleFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_SRFSimpleFoam SRFSimpleFoam

unset -f _of_star4ToFoam 2>/dev/null
_of_star4ToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-ascii -noFunctionObjects -solids -srcDoc -doc -help "
    local optsWithArgs="-case -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_star4ToFoam star4ToFoam

unset -f _of_steadyParticleTracks 2>/dev/null
_of_steadyParticleTracks()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help "
    local optsWithArgs="-case -dict -region -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_steadyParticleTracks steadyParticleTracks

unset -f _of_stitchMesh 2>/dev/null
_of_stitchMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -partial -perfect -srcDoc -doc -help "
    local optsWithArgs="-case -region -toleranceDict "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_stitchMesh stitchMesh

unset -f _of_subsetMesh 2>/dev/null
_of_subsetMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -patch -patches -region -resultTime -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_subsetMesh subsetMesh

unset -f _of_surfaceAdd 2>/dev/null
_of_surfaceAdd()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-mergeRegions -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -points "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceAdd surfaceAdd

unset -f _of_surfaceBooleanFeatures 2>/dev/null
_of_surfaceBooleanFeatures()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-invertedSpace -noFunctionObjects -perturb -surf1Baffle -surf2Baffle -srcDoc -doc -help "
    local optsWithArgs="-case -trim "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceBooleanFeatures surfaceBooleanFeatures

unset -f _of_surfaceCheck 2>/dev/null
_of_surfaceCheck()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-blockMesh -checkSelfIntersection -noFunctionObjects -splitNonManifold -verbose -srcDoc -doc -help "
    local optsWithArgs="-case -outputThreshold "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceCheck surfaceCheck

unset -f _of_surfaceClean 2>/dev/null
_of_surfaceClean()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noClean -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceClean surfaceClean

unset -f _of_surfaceCoarsen 2>/dev/null
_of_surfaceCoarsen()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceCoarsen surfaceCoarsen

unset -f _of_surfaceConvert 2>/dev/null
_of_surfaceConvert()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-clean -group -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -scale -writePrecision "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceConvert surfaceConvert

unset -f _of_surfaceFeatureConvert 2>/dev/null
_of_surfaceFeatureConvert()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceFeatureConvert surfaceFeatureConvert

unset -f _of_surfaceFeatureExtract 2>/dev/null
_of_surfaceFeatureExtract()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-srcDoc -doc -help "
    local optsWithArgs="-case -dict "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceFeatureExtract surfaceFeatureExtract

unset -f _of_surfaceFind 2>/dev/null
_of_surfaceFind()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -x -y -z "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceFind surfaceFind

unset -f _of_surfaceHookUp 2>/dev/null
_of_surfaceHookUp()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -dict "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceHookUp surfaceHookUp

unset -f _of_surfaceInertia 2>/dev/null
_of_surfaceInertia()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -shellProperties -srcDoc -doc -help "
    local optsWithArgs="-case -density -referencePoint "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceInertia surfaceInertia

unset -f _of_surfaceInflate 2>/dev/null
_of_surfaceInflate()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-checkSelfIntersection -debug -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -featureAngle -nSmooth "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceInflate surfaceInflate

unset -f _of_surfaceLambdaMuSmooth 2>/dev/null
_of_surfaceLambdaMuSmooth()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-srcDoc -doc -help "
    local optsWithArgs="-featureFile "

    case ${prev} in

        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceLambdaMuSmooth surfaceLambdaMuSmooth

unset -f _of_surfaceMeshConvert 2>/dev/null
_of_surfaceMeshConvert()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-clean -noFunctionObjects -tri -srcDoc -doc -help "
    local optsWithArgs="-case -dict -from -scaleIn -scaleOut -to "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceMeshConvert surfaceMeshConvert

unset -f _of_surfaceMeshConvertTesting 2>/dev/null
_of_surfaceMeshConvertTesting()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-clean -noFunctionObjects -orient -stdout -surfMesh -testModify -triFace -triSurface -unsorted -srcDoc -doc -help "
    local optsWithArgs="-case -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceMeshConvertTesting surfaceMeshConvertTesting

unset -f _of_surfaceMeshExport 2>/dev/null
_of_surfaceMeshExport()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-clean -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -dict -from -name -scaleIn -scaleOut -to "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceMeshExport surfaceMeshExport

unset -f _of_surfaceMeshImport 2>/dev/null
_of_surfaceMeshImport()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-clean -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -dict -from -name -scaleIn -scaleOut -to "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceMeshImport surfaceMeshImport

unset -f _of_surfaceMeshInfo 2>/dev/null
_of_surfaceMeshInfo()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-areas -noFunctionObjects -xml -srcDoc -doc -help "
    local optsWithArgs="-case -scale "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceMeshInfo surfaceMeshInfo

unset -f _of_surfaceMeshTriangulate 2>/dev/null
_of_surfaceMeshTriangulate()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -excludeProcPatches -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -faceZones -patches -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceMeshTriangulate surfaceMeshTriangulate

unset -f _of_surfaceOrient 2>/dev/null
_of_surfaceOrient()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-inside -noFunctionObjects -usePierceTest -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceOrient surfaceOrient

unset -f _of_surfacePatch 2>/dev/null
_of_surfacePatch()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -dict "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfacePatch surfacePatch

unset -f _of_surfacePointMerge 2>/dev/null
_of_surfacePointMerge()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfacePointMerge surfacePointMerge

unset -f _of_surfaceRedistributePar 2>/dev/null
_of_surfaceRedistributePar()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-keepNonMapped -noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceRedistributePar surfaceRedistributePar

unset -f _of_surfaceRefineRedGreen 2>/dev/null
_of_surfaceRefineRedGreen()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceRefineRedGreen surfaceRefineRedGreen

unset -f _of_surfaceSplitByPatch 2>/dev/null
_of_surfaceSplitByPatch()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceSplitByPatch surfaceSplitByPatch

unset -f _of_surfaceSplitByTopology 2>/dev/null
_of_surfaceSplitByTopology()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-srcDoc -doc -help "
    local optsWithArgs=" "

    case ${prev} in

        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceSplitByTopology surfaceSplitByTopology

unset -f _of_surfaceSplitNonManifolds 2>/dev/null
_of_surfaceSplitNonManifolds()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-debug -noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceSplitNonManifolds surfaceSplitNonManifolds

unset -f _of_surfaceSubset 2>/dev/null
_of_surfaceSubset()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceSubset surfaceSubset

unset -f _of_surfaceToPatch 2>/dev/null
_of_surfaceToPatch()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -faceSet -tol "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceToPatch surfaceToPatch

unset -f _of_surfaceTransformPoints 2>/dev/null
_of_surfaceTransformPoints()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case -rollPitchYaw -rotate -scale -translate -yawPitchRoll "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_surfaceTransformPoints surfaceTransformPoints

unset -f _of_temporalInterpolate 2>/dev/null
_of_temporalInterpolate()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -divisions -fields -interpolationType -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_temporalInterpolate temporalInterpolate

unset -f _of_tetgenToFoam 2>/dev/null
_of_tetgenToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFaceFile -noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_tetgenToFoam tetgenToFoam

unset -f _of_thermoFoam 2>/dev/null
_of_thermoFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_thermoFoam thermoFoam

unset -f _of_topoSet 2>/dev/null
_of_topoSet()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFunctionObjects -noSync -noZero -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -dict -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_topoSet topoSet

unset -f _of_transformPoints 2>/dev/null
_of_transformPoints()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -rotateFields -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -rollPitchYaw -roots -rotate -scale -translate -yawPitchRoll "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_transformPoints transformPoints

unset -f _of_twoLiquidMixingFoam 2>/dev/null
_of_twoLiquidMixingFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_twoLiquidMixingFoam twoLiquidMixingFoam

unset -f _of_twoPhaseEulerFoam 2>/dev/null
_of_twoPhaseEulerFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_twoPhaseEulerFoam twoPhaseEulerFoam

unset -f _of_uncoupledKinematicParcelFoam 2>/dev/null
_of_uncoupledKinematicParcelFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -cloud -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_uncoupledKinematicParcelFoam uncoupledKinematicParcelFoam

unset -f _of_viewFactorsGen 2>/dev/null
_of_viewFactorsGen()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_viewFactorsGen viewFactorsGen

unset -f _of_vtkUnstructuredToFoam 2>/dev/null
_of_vtkUnstructuredToFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -srcDoc -doc -help "
    local optsWithArgs="-case "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_vtkUnstructuredToFoam vtkUnstructuredToFoam

unset -f _of_wallFunctionTable 2>/dev/null
_of_wallFunctionTable()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_wallFunctionTable wallFunctionTable

unset -f _of_writeMeshObj 2>/dev/null
_of_writeMeshObj()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -patchEdges -patchFaces -srcDoc -doc -help "
    local optsWithArgs="-case -cell -cellSet -decomposeParDict -face -faceSet -point -region -roots -time "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        -time)
            COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_writeMeshObj writeMeshObj

unset -f _of_XiDyMFoam 2>/dev/null
_of_XiDyMFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_XiDyMFoam XiDyMFoam

unset -f _of_XiFoam 2>/dev/null
_of_XiFoam()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_XiFoam XiFoam

unset -f _of_zipUpMesh 2>/dev/null
_of_zipUpMesh()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
    local optsWithArgs="-case -decomposeParDict -region -roots "

    case ${prev} in
        -case)
            COMPREPLY=($(compgen -d -- ${cur}))
            ;;
        *Dict)
            COMPREPLY=($(compgen -f -- ${cur}))
            ;;
        -region)
            local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
            COMPREPLY=($(compgen -W "$regions" -- ${cur}))
            ;;
        *)
            if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then
                # Unknown what type of arg follows - set to files
                # not always correct but at least can still navigate path if
                # needed...
                COMPREPLY=($(compgen -f -- ${cur}))
            else
                # Catch-all - present all remaining options
                opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
                optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
                COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
            fi
            ;;
    esac

    return 0
}
complete -o nospace -F _of_zipUpMesh zipUpMesh


#------------------------------------------------------------------------------