#----------------------------------*-sh-*--------------------------------------
# =========                 |
# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
#  \\    /   O peration     | Website:  https://openfoam.org
#   \\  /    A nd           | Copyright (C) 2017-2018 OpenFOAM Foundation
#    \\/     M anipulation  |
#------------------------------------------------------------------------------
# License
#     This file is part of OpenFOAM.
#
#     OpenFOAM is free software: you can redistribute it and/or modify it
#     under the terms of the GNU General Public License as published by
#     the Free Software Foundation, either version 3 of the License, or
#     (at your option) any later version.
#
#     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
#     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
#     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
#     for more details.
#
#     You should have received a copy of the GNU General Public License
#     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
#
# File
#     etc/config.sh/bash_completion
#
# Description
#     Bash [TAB] completion file from OpenFOAM
#     Sourced from /etc/bashrc
#
#------------------------------------------------------------------------------

_adiabaticFlameT_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _adiabaticFlameT_ adiabaticFlameT

_adjointShapeOptimizationFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _adjointShapeOptimizationFoam_ adjointShapeOptimizationFoam

_ansysToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -scale|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _ansysToFoam_ ansysToFoam

_applyBoundaryLayer_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -Cbl -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc -writenut -ybl"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -Cbl|-hostRoots|-roots|-ybl)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _applyBoundaryLayer_ applyBoundaryLayer

_attachMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _attachMesh_ attachMesh

_autoPatch_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _autoPatch_ autoPatch

_autoRefineMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _autoRefineMesh_ autoRefineMesh

_blockMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-blockTopology -case -dict -doc -fileHandler -help -noClean -noFunctionObjects -region -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -region)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _blockMesh_ blockMesh

_boundaryFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _boundaryFoam_ boundaryFoam

_boxTurb_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _boxTurb_ boxTurb

_buoyantBoussinesqPimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _buoyantBoussinesqPimpleFoam_ buoyantBoussinesqPimpleFoam

_buoyantBoussinesqSimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _buoyantBoussinesqSimpleFoam_ buoyantBoussinesqSimpleFoam

_buoyantPimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _buoyantPimpleFoam_ buoyantPimpleFoam

_buoyantSimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _buoyantSimpleFoam_ buoyantSimpleFoam

_cavitatingDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _cavitatingDyMFoam_ cavitatingDyMFoam

_cavitatingFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _cavitatingFoam_ cavitatingFoam

_cfx4ToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -scale|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _cfx4ToFoam_ cfx4ToFoam

_changeDictionary_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -dict -disablePatchGroups -doc -enableFunctionEntries -fileHandler -help -hostRoots -instance -latestTime -literalRE -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -subDict -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-instance|-region|-roots|-subDict)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _changeDictionary_ changeDictionary

_checkMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-allGeometry -allTopology -case -constant -doc -fileHandler -help -hostRoots -latestTime -meshQuality -newTimes -noFunctionObjects -noTopology -noZero -parallel -region -roots -srcDoc -time -writeSets"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-region|-roots|-writeSets)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _checkMesh_ checkMesh

_chemFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -postProcess -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _chemFoam_ chemFoam

_chemkinToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -newFormat -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *) opts="";;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _chemkinToFoam_ chemkinToFoam

_chtMultiRegionFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _chtMultiRegionFoam_ chtMultiRegionFoam

_coalChemistryFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _coalChemistryFoam_ coalChemistryFoam

_coldEngineFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _coldEngineFoam_ coldEngineFoam

_collapseEdges_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -collapseFaces -collapseFaceSet -constant -dict -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -overwrite -parallel -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -collapseFaceSet|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _collapseEdges_ collapseEdges

_combinePatchFaces_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -concaveAngle -doc -fileHandler -help -hostRoots -meshQuality -noFunctionObjects -overwrite -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -concaveAngle|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _combinePatchFaces_ combinePatchFaces

_compressibleInterDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _compressibleInterDyMFoam_ compressibleInterDyMFoam

_compressibleInterFilmFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _compressibleInterFilmFoam_ compressibleInterFilmFoam

_compressibleInterFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _compressibleInterFoam_ compressibleInterFoam

_compressibleMultiphaseInterFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _compressibleMultiphaseInterFoam_ compressibleMultiphaseInterFoam

_createBaffles_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _createBaffles_ createBaffles

_createExternalCoupledPatchGeometry_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _createExternalCoupledPatchGeometry_ createExternalCoupledPatchGeometry

_createPatch_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _createPatch_ createPatch

_datToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _datToFoam_ datToFoam

_decomposePar_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-allRegions -case -cellDist -constant -copyUniform -copyZero -dict -doc -fields -fileHandler -force -help -ifRequired -latestTime -newTimes -noFunctionObjects -noSets -noZero -region -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -dict|-region)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _decomposePar_ decomposePar

_deformedGeom_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _deformedGeom_ deformedGeom

_dnsFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _dnsFoam_ dnsFoam

_DPMDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -cloudName|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _DPMDyMFoam_ DPMDyMFoam

_DPMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -cloudName|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _DPMFoam_ DPMFoam

_driftFluxFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _driftFluxFoam_ driftFluxFoam

_dsmcFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _dsmcFoam_ dsmcFoam

_dsmcInitialise_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _dsmcInitialise_ dsmcInitialise

_electrostaticFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _electrostaticFoam_ electrostaticFoam

_engineCompRatio_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _engineCompRatio_ engineCompRatio

_engineFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _engineFoam_ engineFoam

_engineSwirl_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _engineSwirl_ engineSwirl

_equilibriumCO_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _equilibriumCO_ equilibriumCO

_equilibriumFlameT_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _equilibriumFlameT_ equilibriumFlameT

_extrude2DMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _extrude2DMesh_ extrude2DMesh

_extrudeMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _extrudeMesh_ extrudeMesh

_extrudeToRegionMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _extrudeToRegionMesh_ extrudeToRegionMesh

_faceAgglomerate_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _faceAgglomerate_ faceAgglomerate

_financialFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _financialFoam_ financialFoam

_fireFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _fireFoam_ fireFoam

_flattenMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _flattenMesh_ flattenMesh

_fluent3DMeshToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -cubit -doc -fileHandler -help -ignoreCellGroups -ignoreFaceGroups -noFunctionObjects -scale -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -ignoreCellGroups|-ignoreFaceGroups|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -ignoreCellGroups|-ignoreFaceGroups|-scale|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _fluent3DMeshToFoam_ fluent3DMeshToFoam

_fluentMeshToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-2D -case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc -writeSets -writeZones"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -2D|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -2D|-scale|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _fluentMeshToFoam_ fluentMeshToFoam

_foamDataToFluent_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamDataToFluent_ foamDataToFluent

_foamDictionary_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-add -diff -disableFunctionEntries -doc -entry -expand -help -includes -keywords -remove -set -srcDoc -value"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -add|-diff|-entry|-set)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -add|-diff|-entry|-set) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamDictionary_ foamDictionary

_foamFormatConvert_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -newTimes -noConstant -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamFormatConvert_ foamFormatConvert

_foamListTimes_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -latestTime -newTimes -noFunctionObjects -noZero -processor -rm -srcDoc -time -withZero"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamListTimes_ foamListTimes

_foamMeshToFluent_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamMeshToFluent_ foamMeshToFluent

_foamSetupCHT_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamSetupCHT_ foamSetupCHT

_foamToEnsight_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-ascii -case -cellZone -constant -doc -faceZones -fields -fileHandler -help -hostRoots -latestTime -newTimes -nodeValues -noFunctionObjects -noPatches -noZero -parallel -patches -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -cellZone|-faceZones|-fields|-hostRoots|-patches|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamToEnsight_ foamToEnsight

_foamToEnsightParts_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-ascii -case -constant -doc -fileHandler -help -index -latestTime -name -newTimes -noFunctionObjects -noMesh -noZero -srcDoc -time -width"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -index|-name|-width)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamToEnsightParts_ foamToEnsightParts

_foamToGMV_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamToGMV_ foamToGMV

_foamToStarMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -latestTime -newTimes -noBnd -noFunctionObjects -noZero -scale -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -scale)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamToStarMesh_ foamToStarMesh

_foamToSurface_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -latestTime -newTimes -noFunctionObjects -noZero -scale -srcDoc -time -tri"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -scale)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamToSurface_ foamToSurface

_foamToTetDualMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -noFunctionObjects -noZero -overwrite -parallel -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots|-time)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamToTetDualMesh_ foamToTetDualMesh

_foamToVTK_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-allPatches -ascii -case -cellSet -constant -doc -excludePatches -faceSet -fields -fileHandler -help -hostRoots -latestTime -nearCellValue -newTimes -noFaceZones -noFunctionObjects -noInternal -noLinks -noPointValues -noZero -parallel -pointSet -poly -region -roots -srcDoc -surfaceFields -time -useTimeName"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -cellSet|-excludePatches|-faceSet|-fields|-hostRoots|-pointSet|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamToVTK_ foamToVTK

_foamUpgradeCyclics_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -enableFunctionEntries -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -test -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamUpgradeCyclics_ foamUpgradeCyclics

_foamyHexMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -checkGeometry -conformationOnly -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamyHexMesh_ foamyHexMesh

_foamyQuadMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -pointsFile -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -pointsFile)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamyQuadMesh_ foamyQuadMesh

_gambitToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -scale|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _gambitToFoam_ gambitToFoam

_gmshToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -keepOrientation -noFunctionObjects -region -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -region)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -region|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _gmshToFoam_ gmshToFoam

_icoFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _icoFoam_ icoFoam

_icoUncoupledKinematicParcelDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -cloudName|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _icoUncoupledKinematicParcelDyMFoam_ icoUncoupledKinematicParcelDyMFoam

_icoUncoupledKinematicParcelFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -cloudName|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _icoUncoupledKinematicParcelFoam_ icoUncoupledKinematicParcelFoam

_ideasUnvToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -dump -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _ideasUnvToFoam_ ideasUnvToFoam

_insideCells_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _insideCells_ insideCells

_interFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _interFoam_ interFoam

_interMixingFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _interMixingFoam_ interMixingFoam

_interPhaseChangeDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _interPhaseChangeDyMFoam_ interPhaseChangeDyMFoam

_interPhaseChangeFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _interPhaseChangeFoam_ interPhaseChangeFoam

_kivaToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -file -fileHandler -help -noFunctionObjects -srcDoc -version -zHeadMin"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -file|-version|-zHeadMin)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _kivaToFoam_ kivaToFoam

_laplacianFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _laplacianFoam_ laplacianFoam

_magneticFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -HdotGradH -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noB -noFunctionObjects -noH -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _magneticFoam_ magneticFoam

_mapFields_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -consistent -doc -fileHandler -help -mapMethod -noFunctionObjects -parallelSource -parallelTarget -sourceRegion -sourceTime -srcDoc -subtract -targetRegion"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -mapMethod|-sourceRegion|-sourceTime|-targetRegion)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -mapMethod|-sourceRegion|-sourceTime|-targetRegion|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mapFields_ mapFields

_mapFieldsPar_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -consistent -doc -fields -fileHandler -help -hostRoots -mapMethod -noFunctionObjects -noLagrangian -parallel -roots -sourceRegion -sourceTime -srcDoc -subtract -targetRegion"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -fields|-hostRoots|-mapMethod|-roots|-sourceRegion|-sourceTime|-targetRegion)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -fields|-hostRoots|-mapMethod|-roots|-sourceRegion|-sourceTime|-targetRegion|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mapFieldsPar_ mapFieldsPar

_mdEquilibrationFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mdEquilibrationFoam_ mdEquilibrationFoam

_mdFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mdFoam_ mdFoam

_mdInitialise_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mdInitialise_ mdInitialise

_mergeMeshes_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-addRegion -case -doc -fileHandler -help -masterRegion -noFunctionObjects -overwrite -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -addRegion|-masterRegion)
            opts="" ; extra="" ;;
       -*) ;;
        *) opts="";;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mergeMeshes_ mergeMeshes

_mergeOrSplitBaffles_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -detectOnly -doc -fields -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -region -roots -split -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mergeOrSplitBaffles_ mergeOrSplitBaffles

_mhdFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mhdFoam_ mhdFoam

_mirrorMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mirrorMesh_ mirrorMesh

_mixtureAdiabaticFlameT_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mixtureAdiabaticFlameT_ mixtureAdiabaticFlameT

_modifyMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _modifyMesh_ modifyMesh

_moveDynamicMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -checkAMI -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _moveDynamicMesh_ moveDynamicMesh

_moveEngineMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _moveEngineMesh_ moveEngineMesh

_moveMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _moveMesh_ moveMesh

_MPPICDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -cloudName|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _MPPICDyMFoam_ MPPICDyMFoam

_MPPICFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -cloudName|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _MPPICFoam_ MPPICFoam

_mshToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hex -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mshToFoam_ mshToFoam

_multiphaseEulerFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _multiphaseEulerFoam_ multiphaseEulerFoam

_multiphaseInterFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _multiphaseInterFoam_ multiphaseInterFoam

_netgenNeutralToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -hostRoots|-roots|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _netgenNeutralToFoam_ netgenNeutralToFoam

_noise_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dict -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _noise_ noise

_nonNewtonianIcoFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _nonNewtonianIcoFoam_ nonNewtonianIcoFoam

_objToVTK_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _objToVTK_ objToVTK

_orientFaceZone_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _orientFaceZone_ orientFaceZone

_particleTracks_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _particleTracks_ particleTracks

_patchSummary_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -expand -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _patchSummary_ patchSummary

_pdfPlot_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _pdfPlot_ pdfPlot

_PDRFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _PDRFoam_ PDRFoam

_PDRMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _PDRMesh_ PDRMesh

_pimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _pimpleFoam_ pimpleFoam

_pisoFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _pisoFoam_ pisoFoam

_plot3dToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-2D -case -doc -fileHandler -help -noBlank -noFunctionObjects -scale -singleBlock -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -2D|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -2D|-scale|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _plot3dToFoam_ plot3dToFoam

_polyDualMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -concaveMultiCells -doc -doNotPreserveFaceZones -fileHandler -help -noFunctionObjects -overwrite -splitAllFaces -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _polyDualMesh_ polyDualMesh

_porousSimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _porousSimpleFoam_ porousSimpleFoam

_postChannel_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _postChannel_ postChannel

_postProcess_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -dict -doc -field -fields -fileHandler -func -funcs -help -hostRoots -latestTime -list -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -field|-fields|-func|-funcs|-hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _postProcess_ postProcess

_potentialFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -initialiseUBCs -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -pName -roots -srcDoc -withFunctionObjects -writep -writePhi"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-pName|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _potentialFoam_ potentialFoam

_potentialFreeSurfaceDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _potentialFreeSurfaceDyMFoam_ potentialFreeSurfaceDyMFoam

_potentialFreeSurfaceFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _potentialFreeSurfaceFoam_ potentialFreeSurfaceFoam

_reactingFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _reactingFoam_ reactingFoam

_reactingMultiphaseEulerFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _reactingMultiphaseEulerFoam_ reactingMultiphaseEulerFoam

_reactingParcelFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _reactingParcelFoam_ reactingParcelFoam

_reactingTwoPhaseEulerFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _reactingTwoPhaseEulerFoam_ reactingTwoPhaseEulerFoam

_reconstructPar_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="- -allRegions -case -constant -doc -fields -fileHandler -help -lagrangianFields -latestTime -newTimes -noFields -noFunctionObjects -noLagrangian -noSets -noZero -region -srcDoc -time -withZero"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -fields|-lagrangianFields|-region)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _reconstructPar_ reconstructPar

_reconstructParMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-allRegions -case -cellDist -constant -doc -fileHandler -fullMatch -help -latestTime -mergeTol -newTimes -noFunctionObjects -noZero -region -srcDoc -time -withZero"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -mergeTol|-region)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _reconstructParMesh_ reconstructParMesh

_redistributePar_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -mergeTol -newTimes -noFunctionObjects -noZero -overwrite -parallel -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-mergeTol|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _redistributePar_ redistributePar

_refineHexMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -minSet -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _refineHexMesh_ refineHexMesh

_refinementLevel_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -readLevel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _refinementLevel_ refinementLevel

_refineMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-all -case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _refineMesh_ refineMesh

_refineWallLayer_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -srcDoc -useSet"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -useSet)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _refineWallLayer_ refineWallLayer

_removeFaces_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _removeFaces_ removeFaces

_renumberMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -dict -doc -fileHandler -frontWidth -help -hostRoots -latestTime -noFields -noFunctionObjects -noZero -overwrite -parallel -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots|-time)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _renumberMesh_ renumberMesh

_rhoCentralDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rhoCentralDyMFoam_ rhoCentralDyMFoam

_rhoCentralFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rhoCentralFoam_ rhoCentralFoam

_rhoPimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rhoPimpleFoam_ rhoPimpleFoam

_rhoPorousSimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rhoPorousSimpleFoam_ rhoPorousSimpleFoam

_rhoReactingBuoyantFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rhoReactingBuoyantFoam_ rhoReactingBuoyantFoam

_rhoReactingFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rhoReactingFoam_ rhoReactingFoam

_rhoSimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rhoSimpleFoam_ rhoSimpleFoam

_rotateMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rotateMesh_ rotateMesh

_sammToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -scale)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _sammToFoam_ sammToFoam

_scalarTransportFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _scalarTransportFoam_ scalarTransportFoam

_selectCells_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _selectCells_ selectCells

_setFields_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _setFields_ setFields

_setSet_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-batch -case -constant -doc -fileHandler -help -hostRoots -latestTime -loop -newTimes -noFunctionObjects -noSync -noVTK -noZero -parallel -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -batch)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _setSet_ setSet

_setsToZones_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFlipMap -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots|-time)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _setsToZones_ setsToZones

_setWaves_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-alpha -case -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -roots -srcDoc -time -U"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -U|-alpha|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _setWaves_ setWaves

_shallowWaterFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _shallowWaterFoam_ shallowWaterFoam

_simpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _simpleFoam_ simpleFoam

_simpleReactingParcelFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _simpleReactingParcelFoam_ simpleReactingParcelFoam

_singleCellMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _singleCellMesh_ singleCellMesh

_smapToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _smapToFoam_ smapToFoam

_snappyHexMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -checkGeometry -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -outFile -overwrite -parallel -patches -roots -srcDoc -surfaceSimplify"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict|-outFile)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-patches|-roots|-surfaceSimplify)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _snappyHexMesh_ snappyHexMesh

_solidDisplacementFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _solidDisplacementFoam_ solidDisplacementFoam

_solidEquilibriumDisplacementFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _solidEquilibriumDisplacementFoam_ solidEquilibriumDisplacementFoam

_sonicDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _sonicDyMFoam_ sonicDyMFoam

_sonicFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _sonicFoam_ sonicFoam

_sonicLiquidFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _sonicLiquidFoam_ sonicLiquidFoam

_splitCells_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -geometry -help -noFunctionObjects -overwrite -set -srcDoc -tol"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -set|-tol)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _splitCells_ splitCells

_splitMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _splitMesh_ splitMesh

_splitMeshRegions_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-blockedFaces -case -cellZones -cellZonesFileOnly -cellZonesOnly -defaultRegionName -detectOnly -doc -fileHandler -help -hostRoots -insidePoint -largestOnly -makeCellZones -noFunctionObjects -overwrite -parallel -prefixRegion -region -roots -sloppyCellZones -srcDoc -useFaceZones"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -cellZonesFileOnly)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -blockedFaces|-defaultRegionName|-hostRoots|-insidePoint|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _splitMeshRegions_ splitMeshRegions

_sprayDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _sprayDyMFoam_ sprayDyMFoam

_sprayFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _sprayFoam_ sprayFoam

_SRFPimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _SRFPimpleFoam_ SRFPimpleFoam

_SRFSimpleFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _SRFSimpleFoam_ SRFSimpleFoam

_star3ToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -scale)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _star3ToFoam_ star3ToFoam

_star4ToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-ascii -case -doc -fileHandler -help -noFunctionObjects -scale -solids -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -scale)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _star4ToFoam_ star4ToFoam

_steadyParticleTracks_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -dict -doc -fileHandler -help -latestTime -newTimes -noFunctionObjects -noZero -region -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -region)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _steadyParticleTracks_ steadyParticleTracks

_stitchMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -partial -perfect -region -srcDoc -toleranceDict"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -toleranceDict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -region)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _stitchMesh_ stitchMesh

_subsetMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -patch -region -resultTime -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-patch|-region|-resultTime|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _subsetMesh_ subsetMesh

_surfaceAdd_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -mergeRegions -points -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -points)
            opts="" ; extra="-d -f" ;;
       -*) ;;
        *) opts="";;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceAdd_ surfaceAdd

_surfaceAutoPatch_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceAutoPatch_ surfaceAutoPatch

_surfaceBooleanFeatures_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -invertedSpace -noFunctionObjects -perturb -srcDoc -surf1Baffle -surf2Baffle"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       -*) ;;
        *) opts="";;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceBooleanFeatures_ surfaceBooleanFeatures

_surfaceCheck_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-blockMesh -checkSelfIntersection -doc -help -splitNonManifold -srcDoc -verbose"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceCheck_ surfaceCheck

_surfaceClean_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -noClean -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceClean_ surfaceClean

_surfaceCoarsen_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceCoarsen_ surfaceCoarsen

_surfaceConvert_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-clean -doc -group -help -scale -srcDoc -writePrecision"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -scale|-writePrecision)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -scale|-writePrecision) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceConvert_ surfaceConvert

_surfaceFeatureConvert_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -scale|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceFeatureConvert_ surfaceFeatureConvert

_surfaceFeatureExtract_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dict -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceFeatureExtract_ surfaceFeatureExtract

_surfaceFeatures_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dict -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceFeatures_ surfaceFeatures

_surfaceFind_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc -x -y -z"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -x|-y|-z)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -x|-y|-z) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceFind_ surfaceFind

_surfaceHookUp_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dict -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceHookUp_ surfaceHookUp

_surfaceInertia_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-density -doc -help -referencePoint -shellProperties -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -density|-referencePoint)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -density|-referencePoint) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceInertia_ surfaceInertia

_surfaceLambdaMuSmooth_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -featureFile -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -featureFile)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -featureFile) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceLambdaMuSmooth_ surfaceLambdaMuSmooth

_surfaceMeshConvert_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -clean -dict -doc -fileHandler -from -help -noFunctionObjects -scaleIn -scaleOut -srcDoc -to -tri"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -from|-scaleIn|-scaleOut|-to)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -from|-scaleIn|-scaleOut|-to|-case|-dict|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceMeshConvert_ surfaceMeshConvert

_surfaceMeshConvertTesting_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-clean -doc -help -orient -scale -srcDoc -surfMesh -triFace -triSurface -unsorted"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -scale) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceMeshConvertTesting_ surfaceMeshConvertTesting

_surfaceMeshExport_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -clean -dict -doc -fileHandler -from -help -name -noFunctionObjects -scaleIn -scaleOut -srcDoc -to"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -from|-name|-scaleIn|-scaleOut|-to)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceMeshExport_ surfaceMeshExport

_surfaceMeshImport_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -clean -dict -doc -fileHandler -from -help -name -noFunctionObjects -scaleIn -scaleOut -srcDoc -to"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -from|-name|-scaleIn|-scaleOut|-to)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -from|-name|-scaleIn|-scaleOut|-to|-case|-dict|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceMeshImport_ surfaceMeshImport

_surfaceMeshInfo_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-areas -case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc -xml"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -scale|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceMeshInfo_ surfaceMeshInfo

_surfaceMeshTriangulate_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -excludeProcPatches -faceZones -fileHandler -help -hostRoots -noFunctionObjects -parallel -patches -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -faceZones|-hostRoots|-patches|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceMeshTriangulate_ surfaceMeshTriangulate

_surfaceOrient_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -inside -srcDoc -usePierceTest"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceOrient_ surfaceOrient

_surfacePointMerge_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfacePointMerge_ surfacePointMerge

_surfaceRedistributePar_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -keepNonMapped -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -hostRoots|-roots|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceRedistributePar_ surfaceRedistributePar

_surfaceRefineRedGreen_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceRefineRedGreen_ surfaceRefineRedGreen

_surfaceSplitByPatch_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceSplitByPatch_ surfaceSplitByPatch

_surfaceSplitByTopology_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceSplitByTopology_ surfaceSplitByTopology

_surfaceSplitNonManifolds_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-debug -doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceSplitNonManifolds_ surfaceSplitNonManifolds

_surfaceSubset_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceSubset_ surfaceSubset

_surfaceToPatch_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -faceSet -fileHandler -help -noFunctionObjects -srcDoc -tol"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -faceSet|-tol)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -faceSet|-tol|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceToPatch_ surfaceToPatch

_surfaceTransformPoints_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-doc -help -rollPitchYaw -rotate -scale -srcDoc -translate -yawPitchRoll"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -rollPitchYaw|-rotate|-scale|-translate|-yawPitchRoll)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -rollPitchYaw|-rotate|-scale|-translate|-yawPitchRoll) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceTransformPoints_ surfaceTransformPoints

_temporalInterpolate_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -divisions -doc -fields -fileHandler -help -hostRoots -interpolationType -latestTime -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -divisions|-fields|-hostRoots|-interpolationType|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _temporalInterpolate_ temporalInterpolate

_tetgenToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFaceFile -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _tetgenToFoam_ tetgenToFoam

_thermoFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _thermoFoam_ thermoFoam

_topoSet_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -constant -dict -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noSync -noZero -parallel -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _topoSet_ topoSet

_transformPoints_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-allRegions -case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -rollPitchYaw -roots -rotate -rotateFields -scale -srcDoc -translate -yawPitchRoll"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-rollPitchYaw|-roots|-rotate|-scale|-translate|-yawPitchRoll)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _transformPoints_ transformPoints

_twoLiquidMixingFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _twoLiquidMixingFoam_ twoLiquidMixingFoam

_twoPhaseEulerFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _twoPhaseEulerFoam_ twoPhaseEulerFoam

_uncoupledKinematicParcelDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -cloudName|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _uncoupledKinematicParcelDyMFoam_ uncoupledKinematicParcelDyMFoam

_uncoupledKinematicParcelFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -cloudName|-hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _uncoupledKinematicParcelFoam_ uncoupledKinematicParcelFoam

_viewFactorsGen_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _viewFactorsGen_ viewFactorsGen

_vtkUnstructuredToFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _vtkUnstructuredToFoam_ vtkUnstructuredToFoam

_wallFunctionTable_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wallFunctionTable_ wallFunctionTable

_writeMeshObj_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -cell -cellSet -constant -doc -face -faceSet -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -patchEdges -patchFaces -point -region -roots -srcDoc -time"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -cell|-cellSet|-face|-faceSet|-hostRoots|-point|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _writeMeshObj_ writeMeshObj

_XiEngineFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _XiEngineFoam_ XiEngineFoam

_XiFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _XiFoam_ XiFoam

_zipUpMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -hostRoots|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _zipUpMesh_ zipUpMesh

_foamCleanPath_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -strip"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamCleanPath_ foamCleanPath

_foamCleanPolyMesh_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -help -region"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -region)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamCleanPolyMesh_ foamCleanPolyMesh

_foamCleanTutorials_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamCleanTutorials_ foamCleanTutorials

_foamCloneCase_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -latestTime -no-orig -no-scripts -template"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamCloneCase_ foamCloneCase

_foamCreateVideo_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-dir -fps -help -image -out -start -webm"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -dir)
            opts="" ; extra="-d" ;;
        -fps|-image|-out|-start)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamCreateVideo_ foamCreateVideo

_foamEtcFile_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-all -help -list -mode -prefix -quiet -silent -version"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -prefix)
            opts="" ; extra="-d" ;;
        -mode|-version)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamEtcFile_ foamEtcFile

_foamExec_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -prefix -version"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -prefix)
            opts="" ; extra="-d" ;;
        -version)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamExec_ foamExec

_foamGet_ ()
{
    _searchDirs () {
        _dirs=="\
            ${HOME}/.OpenFOAM \
            $WM_PROJECT_SITE \
            $WM_PROJECT_INST_DIR/site \
            $FOAM_ETC/caseDicts"

        _files=""
        for _d in $_dirs
        do
            [ -d "$_d" ] && \
                _files="$_files $(find "$_d" -type f ! -name "*.*" -exec basename {} \;)"
        done
        echo "${_files}" | xargs -n 1 | sort -u
    }

    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used
    used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -ext -help -no-ext -target"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""
    opts="${opts} $(_searchDirs)"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case|-target)
            opts="" ; extra="-d" ;;
        -ext)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -case|-ext|-target) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- "${cur}") )
}
complete -o filenames -o nospace -F _foamGet_ foamGet

_foamInfo_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-all -browser -help -web"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -browser)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamInfo_ foamInfo

_foamJob_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-append -case -help -parallel -screen -version -wait"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -version)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamJob_ foamJob

_foamLog_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -list -localDB -n -quiet"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamLog_ foamLog

_foamMonitor_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -idle -logscale -refresh -title -yrange"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -idle|-title|-refresh|-yrange)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -idle|-title|-refresh|-yrange) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamMonitor_ foamMonitor

_foamNew_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -source -template"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -source|-template)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamNew_ foamNew

_foamNewApp_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamNewApp_ foamNewApp

_foamNewBC_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamNewBC_ foamNewBC

_foamNewFunctionObject_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamNewFunctionObject_ foamNewFunctionObject

_foamRunTutorials_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -skipFirst -test"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamRunTutorials_ foamRunTutorials

_foamSearch_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-count -help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamSearch_ foamSearch

_foamSequenceVTKFiles_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-case -dir -help -out"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case|-dir|-out)
            opts="" ; extra="-d" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamSequenceVTKFiles_ foamSequenceVTKFiles

_foamTags_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamTags_ foamTags

_foamUpdateCaseFileHeader_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -version"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -version)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamUpdateCaseFileHeader_ foamUpdateCaseFileHeader

_mergedDyM_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts=""
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mergedDyM_ mergedDyM

_mpirunDebug_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mpirunDebug_ mpirunDebug

_paraFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-block -builtin -case -help -region -touch -touchAll"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -case)
            opts="" ; extra="-d" ;;
        -region)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _paraFoam_ paraFoam

_pimpleDyMFoam_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts=""
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _pimpleDyMFoam_ pimpleDyMFoam

_surfaceFeatureExtract_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts=""
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceFeatureExtract_ surfaceFeatureExtract

_wclean_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -silent"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wclean_ wclean

_wcleanLnIncludeAll_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts=""
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *) opts="";;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wcleanLnIncludeAll_ wcleanLnIncludeAll

_wcleanPlatform_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-all -current -help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wcleanPlatform_ wcleanPlatform

_wdep_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wdep_ wdep

_wmake_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-all -help -j -j -non-stop -no-scheduler -queue -silent -update"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -j)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -j) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wmake_ wmake

_wmakeCheckPwd_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -quiet"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wmakeCheckPwd_ wmakeCheckPwd

_wmakeCollect_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-clean -help -kill"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wmakeCollect_ wmakeCollect

_wmakeFilesAndOptions_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wmakeFilesAndOptions_ wmakeFilesAndOptions

_wmakeLnInclude_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -silent -update"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wmakeLnInclude_ wmakeLnInclude

_wmakeLnIncludeAll_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help -j -j"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -j)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -j) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wmakeLnIncludeAll_ wmakeLnIncludeAll

_wmakePrintBuild_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-check -help -major -pkg -short -update -version"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -pkg|-version)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wmakePrintBuild_ wmakePrintBuild

_wmakeScheduler_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts=""
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wmakeScheduler_ wmakeScheduler

_wmakeSchedulerUptime_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wmakeSchedulerUptime_ wmakeSchedulerUptime

_wrmdep_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts=""
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wrmdep_ wrmdep

_wrmo_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    opts="-all -help"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
       -*) ;;
        *)
            opts=""; extra=""
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _wrmo_ wrmo

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