        Create a new TopGit-controlled topic branch of the given name
        (required argument) and switch to it.  If no dependencies are
        specified (by extra arguments passed after the first one), the
        current branch is assumed to be the only dependency.

        By default `tg create` opens an editor on the new `.topmsg` file
        and then commits the new `.topmsg` and `.topdeps` files
        automatically with a suitable default commit message.

        The commit message can be changed with the `-m` (or `--message`) or
        `-F` (or `--file`) option.  The automatic commit can be suppressed
        by using the `--no-commit` (or `-n`) option.  Running the editor on
        the new `.topmsg` file can be suppressed by using `--no-edit`
        (which does *NOT* suppress the automatic commit unless `--no-commit`
        is also given) or by providing an explicit value for the new
        `.topmsg` file using the `--topmsg` or `--topmsg-file` option.
        In any case the `.topmsg` content will be automatically reformated to
        have a `Subject:` header line if needed.

        If the `format.signoff` config variable (see `git help config`)
        has been set to true then the `Signed-off-by:` header line added to
        the end of the initial version of the `.topmsg` file will be
        uncommented by default.  Otherwise it will still be there but will be
        commented out and will be automatically stripped if no action is taken
        to remove the comment character.

        If more than one dependency is listed an automatic `tg update` runs
        after the branch has been created to merge in the additional
        dependencies and bring the branch up-to-date.  This can be suppressed
        with the `--no-commit` option (which also suppresses the initial
        commit) or the `--no-update` option (which allows the initial commit
        while suppressing only the update operation portion).

        Previous versions of TopGit behaved as though both the `--no-edit`
        and `--no-commit` options were always given on the command line.

        The default behavior has been changed to promote a separation between
        commits that modify `.topmsg` and/or `.topdeps` and commits that
        modify other files.  This facilitates cleaner cherry picking and other
        patch maintenance activities.

        You should edit the patch description (contained in the `.topmsg`
        file) as appropriate.  It will already contain some prefilled bits.
        You can set the `topgit.to`, `topgit.cc` and `topgit.bcc`
        git configuration variables (see `git help config`) in order to
        have `tg create` add these headers with the given default values
        to `.topmsg` before invoking the editor.  If the configuration
        variable `topgit.subjectPrefix` is set its value will be inserted
        *between* the initial `[` and the word `PATCH` in the subject
        line (with a space added before the word `PATCH` of course).

        The main task of `tg create` is to set up the topic branch base
        from the dependencies.  This may fail due to merge conflicts if more
        than one dependency is given.   In that case, after you commit the
        conflict resolution, you should call `tg update --continue` to
        finish merging the dependencies into the new topic branch base.

        With the `--base` (aka `--no-deps`) option at most one dependency
        may be listed which may be any valid committish (instead of just
        refs/heads/...) and the newly created TopGit-controlled branch will
        have an empty `.topdeps` file.  This may be desirable in order to
        create a TopGit-controlled branch that has no changes of its own and
        serves merely to mark the common dependency that all other
        TopGit-controlled branches in some set of TopGit-controlled branches
        depend on.  A plain, non-TopGit-controlled branch can be used for the
        same purpose, but the advantage of a TopGit-controlled branch with no
        dependencies is that it will be pushed with `tg push`, it will show
        up in the `tg summary` and `tg info` output with the subject from
        its `.topmsg` file thereby documenting what it's for and finally it
        can be set up with `tg create -r` and/or `tg remote --populate` to
        facilitate sharing.

        For example, `tg create --base t/release v2.1` will create a TopGit-
        controlled `t/release` branch based off the `v2.1` tag that can then
        be used as a base for creation of other TopGit-controlled branches.
        Then when the time comes to move the base for an entire set of changes
        up to `v2.2` the command `tg update --base t/release v2.2` can be
        used followed by `tg update --all`.

        Using `--base` it's also possible to use `tg create` on an
        unborn branch (omit the dependency name or specify `HEAD`).  The
        unborn branch itself can be made into the new TopGit branch (rather
        than being born empty and then having the new TopGit branch based off
        that) by specifying `HEAD` as the new branch's name (which is
        probably what you normally want to do in this case anyway so you can
        just run `tg create --base HEAD` to accomplish that).

        In an alternative use case, if `-r <rbranch>` is given instead of a
        dependency list, the topic branch is created based on the given
        remote branch.  With just `-r` the remote branch name is assumed
        to be the same as the local topic branch being created.  Since no
        new commits are created in this mode (only two refs will be updated)
        the editor will never be run for this use case.  Note that no other
        options may be combined with `-r` although a global `-r` option
        can be used to alter which remote `<rbranch>` refers to.

        The `--quiet` (or `-q`) option suppresses most informational
        messages.

