#----------------------------------*-sh-*--------------------------------------
# =========                 |
# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
#  \\    /   O peration     | Website:  https://openfoam.org
#   \\  /    A nd           | Copyright (C) 2017-2022 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

_adjointShapeOptimisationFoam_ ()
{
    local cur="${COMP_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _adjointShapeOptimisationFoam_ adjointShapeOptimisationFoam

_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 -libs -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="" ;;
        -libs|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-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 -libs -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|-libs|-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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -libs -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="" ;;
        -libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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="" ;;
        -libs)
            opts="" ; 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 -libs -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="" ;;
        -libs)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _boxTurb_ boxTurb

_buoyantFoam_ ()
{
    local cur="${COMP_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _buoyantFoam_ buoyantFoam

_buoyantReactingFoam_ ()
{
    local cur="${COMP_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _buoyantReactingFoam_ buoyantReactingFoam

_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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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="" ;;
        -libs|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-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 -libs -literalRE -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|-libs|-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 -libs -meshQuality -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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="" ;;
        -libs)
            opts="" ; 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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _chtMultiRegionFoam_ chtMultiRegionFoam

_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 -libs -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|-libs|-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 -libs -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _combinePatchFaces_ combinePatchFaces

_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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="" ;;
        -libs)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-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 -libs -noFields -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" ;;
        -dict)
            opts="" ; extra="-d -f" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -time)
            opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
        -libs|-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 -libs -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _deformedGeom_ deformedGeom

_denseParticleFoam_ ()
{
    local cur="${COMP_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _denseParticleFoam_ denseParticleFoam

_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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _dnsFoam_ dnsFoam

_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -dict -doc -fileHandler -help -hostRoots -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _financialFoam_ financialFoam

_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 -libs -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|-libs|-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 -includedAngle -libs -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|-includedAngle|-libs|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -ignoreCellGroups|-ignoreFaceGroups|-includedAngle|-libs|-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 -libs -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|-libs|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -2D|-libs|-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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -dict -diff -doc -entry -expand -fileHandler -help -hostRoots -includes -keywords -libs -merge -noFunctionObjects -parallel -remove -roots -set -srcDoc -value -writePrecision"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -add|-diff|-entry|-hostRoots|-libs|-merge|-roots|-set|-writePrecision)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -add|-diff|-entry|-hostRoots|-libs|-merge|-roots|-set|-writePrecision|-fileHandler) ;;
                *) 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 -libs -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|-libs|-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 -libs -noFunctionObjects -noZero -processor -rm -srcDoc -time -withFunctionEntries -withFunctionObjects -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="" ;;
        -libs)
            opts="" ; 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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -name -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|-libs|-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 -libs -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|-libs|-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 -libs -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="" ;;
        -libs|-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 -libs -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="" ;;
        -libs|-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 -libs -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|-libs|-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 -libs -nearCellValue -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|-libs|-pointSet|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _foamToVTK_ foamToVTK

_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 -libs -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|-libs|-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 -libs -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="" ;;
        -libs|-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 -libs -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="" ;;
        -libs|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-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 -libs -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="" ;;
        -libs|-region)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _icoFoam_ icoFoam

_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 -libs -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="" ;;
        -libs|-region)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-region|-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 -libs -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="" ;;
        -libs)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _interMixingFoam_ interMixingFoam

_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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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="" ;;
        -libs|-mapMethod|-sourceRegion|-sourceTime|-targetRegion)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-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 -libs -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|-libs|-mapMethod|-roots|-sourceRegion|-sourceTime|-targetRegion)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -fields|-hostRoots|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mdInitialise_ mdInitialise

_mergeBaffles_ ()
{
    local cur="${COMP_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 -fields -fileHandler -help -hostRoots -libs -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|-libs|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mergeBaffles_ mergeBaffles

_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 -libs -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|-libs|-masterRegion)
            opts="" ; extra="" ;;
       -*) ;;
        *) opts="";;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _mergeMeshes_ mergeMeshes

_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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _modifyMesh_ modifyMesh

_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 -checkAMI -doc -fileHandler -help -hostRoots -libs -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|-libs|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _moveMesh_ moveMesh

_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 -libs -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="" ;;
        -libs)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-roots)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -hostRoots|-libs|-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 -libs -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="" ;;
        -libs)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _noise_ noise

_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 -libs -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|-libs|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _orientFaceZone_ orientFaceZone

_particleFoam_ ()
{
    local cur="${COMP_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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _particleFoam_ particleFoam

_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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -2D|-libs|-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 -libs -noFields -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="" ;;
        -libs)
            opts="" ; 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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -libs -list -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-pName|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _potentialFoam_ potentialFoam

_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _reactingFoam_ reactingFoam

_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 -libs -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|-libs|-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 -help -latestTime -libs -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="" ;;
        -libs|-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 -libs -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|-libs|-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 -libs -minSet -noFields -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -inSet -libs -noFunctionObjects -overwrite -region -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="" ;;
        -inSet|-libs|-region)
            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 -libs -noFields -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|-libs|-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 -libs -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|-libs|-region|-roots|-time)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _renumberMesh_ renumberMesh

_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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rhoCentralFoam_ rhoCentralFoam

_rhoParticleFoam_ ()
{
    local cur="${COMP_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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rhoParticleFoam_ rhoParticleFoam

_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _rhoPorousSimpleFoam_ rhoPorousSimpleFoam

_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -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="" ;;
        -libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -libs -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|-libs|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _setFields_ setFields

_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 -libs -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|-libs|-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 -dict -doc -fileHandler -gas -help -hostRoots -latestTime -libs -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time -U"
    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="" ;;
        -U|-alpha|-hostRoots|-libs|-region|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _simpleFoam_ simpleFoam

_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 -libs -noFields -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|-libs|-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 -libs -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="" ;;
        -libs)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _solidEquilibriumDisplacementFoam_ solidEquilibriumDisplacementFoam

_splitBaffles_ ()
{
    local cur="${COMP_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 -fields -fileHandler -help -hostRoots -libs -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|-libs|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _splitBaffles_ splitBaffles

_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 -libs -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="" ;;
        -libs|-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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -libs -makeCellZones -noFields -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|-libs|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _splitMeshRegions_ splitMeshRegions

_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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="" ;;
        -libs|-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 -libs -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="" ;;
        -libs|-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 -libs -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="" ;;
        -libs|-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 -libs -noFields -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="" ;;
        -libs|-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 -libs -noFields -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|-libs|-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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -libs -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="" ;;
        -libs|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-scale|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _surfaceFeatureConvert_ surfaceFeatureConvert

_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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -libs -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="" ;;
        -libs)
            opts="" ; 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 -doc -fileHandler -from -help -libs -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" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -from|-libs|-scaleIn|-scaleOut|-to)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -from|-libs|-scaleIn|-scaleOut|-to|-case|-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 -doc -fileHandler -from -help -libs -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" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -from|-libs|-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 -doc -fileHandler -from -help -libs -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" ;;
        -fileHandler)
            opts="uncollated collated masterUncollated" ; extra="" ;;
        -from|-libs|-name|-scaleIn|-scaleOut|-to)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -from|-libs|-name|-scaleIn|-scaleOut|-to|-case|-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 -libs -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="" ;;
        -libs|-scale)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-roots)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -hostRoots|-libs|-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 -libs -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|-libs|-tol)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -faceSet|-libs|-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 -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 _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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -noFunctionObjects -parallel -region -roots -rotateFields -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|-libs|-region|-roots)
            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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _twoLiquidMixingFoam_ twoLiquidMixingFoam

_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 -libs -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|-libs|-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 -libs -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="" ;;
        -libs)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -libs|-case|-fileHandler) ;;
                *) opts=""; extra="" ;;
            esac
            ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _vtkUnstructuredToFoam_ vtkUnstructuredToFoam

_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 -libs -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|-libs|-point|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _writeMeshObj_ writeMeshObj

_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 -libs -listFunctionObjects -listFvConstraints -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-region|-roots)
            opts="" ; extra="" ;;
       *) ;;
    esac
    COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
}
complete -o filenames -o nospace -F _zipUpMesh_ zipUpMesh

_foamCleanCase_ ()
{
    local cur="${COMP_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"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra=""

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

_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

_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="-add -help -latestTime -no-orig -no-scripts \
          -processor -startFrom -template"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -startFrom) 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_ ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local line=${COMP_LINE}
    local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")

    _searchDirs () {
        _dirs="\
            ${HOME}/.OpenFOAM/$WM_PROJECT_VERSION \
            ${HOME}/.OpenFOAM"
        [ -n "$WM_PROJECT_SITE" ] && _dirs=" \
                $WM_PROJECT_SITE/$WM_PROJECT_VERSION/etc \
                $WM_PROJECT_SITE/etc"
        _dirs+=" \
            $WM_PROJECT_INST_DIR/site/$WM_PROJECT_VERSION/etc \
            $WM_PROJECT_INST_DIR/site/etc \
            $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
    }

    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 -keyword -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="-ascii -help -idle -logscale -refresh -size -title -yrange"
    for o in $used ; do opts="${opts/$o/}" ; done
    extra="-d -f"

    [ "$COMP_CWORD" = 1 ] || \
    case "$prev" in
        -idle|-title|-refresh|-yrange|-size)
            opts="" ; extra="" ;;
       -*) ;;
        *)
            case "${COMP_WORDS[COMP_CWORD-2]}" in
                -idle|-title|-refresh|-yrange|-size) ;;
                *) 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

_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 -empty -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

_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

_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

_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

_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

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