}
	sort.Strings(commands)

	var help string
	if commandLine {
		help = "  Output formats (select at most one):\n"
	} else {
		help = "  Commands:\n"
		commands = append(commands, fmtHelp("o/options", "List options and their current values"))
		commands = append(commands, fmtHelp("q/quit/exit/^D", "Exit pprof"))
	}

			}
		})
	}
}

// Builds a hierarchy of commands in order from the passed slice of commands,
// by adding each subsequent command as a child of the previous command,
// returning the last leaf command.
func buildCommandChain(commands []*cobra.Command) *cobra.Command {
	var currCmd *cobra.Command
	if len(commands) > 0 {
		currCmd = commands[0]
	}
	for i := 1; i < len(commands); i++ {
		cmd := commands[i]

	Flag flag.FlagSet

	// CustomFlags indicates that the command will do its own
	// flag parsing.
	CustomFlags bool

	// Commands lists the available commands and help topics.
	// The order here is the order in which they are printed by 'go help'.
	// Note that subcommands are in general best avoided.
	Commands []*Command
}

var Go = &Command{
	UsageLine: "go",

		base.Exit()
	}

	if len(cmd.Commands) > 0 {
		PrintUsage(os.Stdout, cmd)
	} else {
		tmpl(os.Stdout, helpTemplate, cmd)
	}
	// not exit 2: succeeded at 'go help cmd'.
	return
}

var usageTemplate = `{{.Long | trim}}

Usage:

	{{.UsageLine}} <command> [arguments]

The commands are:
{{range .Commands}}{{if or (.Runnable) .Commands}}
	{{.Name | printf "%-11s"}} {{.Short}}{{end}}{{end}}

.PHONY: docker
.PHONY: docker.all
.PHONY: docker.save
.PHONY: docker.push

### Docker commands ###
# Below provides various commands to build/push docker images.
# These are all wrappers around ./tools/docker, the binary that controls docker builds.
# Builds can also be done through direct ./tools/docker invocations.
# When using these commands the flow is:
#  1) make target calls ./tools/docker

# The build cache is required to build anything. It also may be needed to
# initialize the build system, which is needed for commands like 'go env'.
# However, there are lots of commands the cache is not needed for, and we
# shouldn't require it when it won't be used.
#
# TODO(golang.org/issue/39882): commands below should work, too.
# * go clean -modcache
# * go env
# * go fix
# * go fmt
# * go generate
# * go get

	if len(command.Example) > 0 {
		fmt.Fprintf(out, "# EXAMPLE\n")
		fmt.Fprintf(out, "```\n%s\n```\n", command.Example)
	}

	if len(command.Commands()) > 0 || len(parent) > 0 {
		fmt.Fprintf(out, "# SEE ALSO\n")
		if len(parent) > 0 {
			fmt.Fprintf(out, "**%s(1)**, ", dparent)
		}
		for _, c := range command.Commands() {
			fmt.Fprintf(out, "**%s-%s(1)**, ", dname, c.Name())
			genMarkdown(c, name, docsDir)

after their parent phase.

The phase runner can be bound to a cobra command; this operation sets the command description
giving evidence of the list of phases, and automatically creates sub commands
for invoking phases atomically.

Autogenerated sub commands get flags according to the following rule:

- global flags will be always inherited by autogenerated commands (this is managed by cobra)

limitations under the License.
*/

/*
Package options provide a central point for defining flags for kubeadm cobra commands,
no matter if hard coded commands or autogenerated command for phases.

New kubeadm flags should always be defined in this package as a constant before their usage,
in order to enforce naming consistency across different commands and to control flag proliferation.

    protected int executeCommand(final String[] commands, final String username, final String password) {
        if (commands == null || commands.length == 0) {
            throw new CommandExecutionException("command is empty.");
        }

        if (logger.isInfoEnabled()) {
            logger.info("Command: {}", String.join(" ", commands));
        }

        final String[] cmds = stream(commands).get(stream -> stream.map(s -> {