diff --git a/vendor/github.com/pborman/getopt/LICENSE b/vendor/github.com/pborman/getopt/LICENSE
new file mode 100644
index 0000000..a8181ec
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2017 Google Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google, nor the names of other
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/pborman/getopt/v2/bool.go b/vendor/github.com/pborman/getopt/v2/bool.go
new file mode 100644
index 0000000..2899bee
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/bool.go
@@ -0,0 +1,36 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+// Bool creates a flag option that is a bool.  Bools normally do not take a
+// value however one can be assigned by using the long form of the option:
+//
+//  --option=true
+//  --o=false
+//
+// The value is case insensitive and one of true, false, t, f, on, off, t and 0.
+func Bool(name rune, helpvalue ...string) *bool {
+	var b bool
+	CommandLine.Flag(&b, name, helpvalue...)
+	return &b
+}
+
+func BoolLong(name string, short rune, helpvalue ...string) *bool {
+	var p bool
+	CommandLine.FlagLong(&p, name, short, helpvalue...)
+	return &p
+}
+
+func (s *Set) Bool(name rune, helpvalue ...string) *bool {
+	var b bool
+	s.Flag(&b, name, helpvalue...)
+	return &b
+}
+
+func (s *Set) BoolLong(name string, short rune, helpvalue ...string) *bool {
+	var p bool
+	s.FlagLong(&p, name, short, helpvalue...)
+	return &p
+}
diff --git a/vendor/github.com/pborman/getopt/v2/counter.go b/vendor/github.com/pborman/getopt/v2/counter.go
new file mode 100644
index 0000000..ab10bc7
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/counter.go
@@ -0,0 +1,69 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type counterValue int
+
+func (b *counterValue) Set(value string, opt Option) error {
+	if value == "" {
+		*b++
+	} else {
+		v, err := strconv.ParseInt(value, 0, strconv.IntSize)
+		if err != nil {
+			if e, ok := err.(*strconv.NumError); ok {
+				switch e.Err {
+				case strconv.ErrRange:
+					err = fmt.Errorf("value out of range: %s", value)
+				case strconv.ErrSyntax:
+					err = fmt.Errorf("not a valid number: %s", value)
+				}
+			}
+			return err
+		}
+		*b = counterValue(v)
+	}
+	return nil
+}
+
+func (b *counterValue) String() string {
+	return strconv.Itoa(int(*b))
+}
+
+// Counter creates a counting flag stored as an int.  Each time the option
+// is seen while parsing the value is incremented.  The value of the counter
+// may be explicitly set by using the long form:
+//
+//  --counter=5
+//  --c=5
+//
+// Further instances of the option will increment from the set value.
+func Counter(name rune, helpvalue ...string) *int {
+	var p int
+	CommandLine.FlagLong((*counterValue)(&p), "", name, helpvalue...).SetFlag()
+	return &p
+}
+
+func (s *Set) Counter(name rune, helpvalue ...string) *int {
+	var p int
+	s.FlagLong((*counterValue)(&p), "", name, helpvalue...).SetFlag()
+	return &p
+}
+
+func CounterLong(name string, short rune, helpvalue ...string) *int {
+	var p int
+	CommandLine.FlagLong((*counterValue)(&p), name, short, helpvalue...).SetFlag()
+	return &p
+}
+
+func (s *Set) CounterLong(name string, short rune, helpvalue ...string) *int {
+	var p int
+	s.FlagLong((*counterValue)(&p), name, short, helpvalue...).SetFlag()
+	return &p
+}
diff --git a/vendor/github.com/pborman/getopt/v2/duration.go b/vendor/github.com/pborman/getopt/v2/duration.go
new file mode 100644
index 0000000..7607815
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/duration.go
@@ -0,0 +1,28 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import "time"
+
+// Duration creates an option that parses its value as a time.Duration.
+func Duration(name rune, value time.Duration, helpvalue ...string) *time.Duration {
+	CommandLine.FlagLong(&value, "", name, helpvalue...)
+	return &value
+}
+
+func (s *Set) Duration(name rune, value time.Duration, helpvalue ...string) *time.Duration {
+	s.FlagLong(&value, "", name, helpvalue...)
+	return &value
+}
+
+func DurationLong(name string, short rune, value time.Duration, helpvalue ...string) *time.Duration {
+	CommandLine.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
+
+func (s *Set) DurationLong(name string, short rune, value time.Duration, helpvalue ...string) *time.Duration {
+	s.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
diff --git a/vendor/github.com/pborman/getopt/v2/enum.go b/vendor/github.com/pborman/getopt/v2/enum.go
new file mode 100644
index 0000000..1ca6ff9
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/enum.go
@@ -0,0 +1,79 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+)
+
+type enumValue string
+
+var (
+	enumValuesMu sync.Mutex
+	enumValues   = make(map[*enumValue]map[string]struct{})
+)
+
+func (s *enumValue) Set(value string, opt Option) error {
+	enumValuesMu.Lock()
+	es, ok := enumValues[s]
+	enumValuesMu.Unlock()
+	if !ok || es == nil {
+		return errors.New("this option has no values")
+	}
+	if _, ok := es[value]; !ok {
+		return errors.New("invalid value: " + value)
+	}
+	*s = enumValue(value)
+	return nil
+}
+
+func (s *enumValue) String() string {
+	return string(*s)
+}
+
+// Enum creates an option that can only be set to one of the enumerated strings
+// passed in values.  Passing nil or an empty slice results in an option that
+// will always fail.  If not "", value is the default value of the enum.  If
+// value is not listed in values then Enum will produce an error on standard
+// error and then exit the program with a status of 1.
+func Enum(name rune, values []string, value string, helpvalue ...string) *string {
+	return CommandLine.Enum(name, values, value, helpvalue...)
+}
+
+func (s *Set) Enum(name rune, values []string, value string, helpvalue ...string) *string {
+	var p enumValue
+	p.define(values, value, &option{short: name})
+	s.FlagLong(&p, "", name, helpvalue...)
+	return (*string)(&p)
+}
+
+func EnumLong(name string, short rune, values []string, value string, helpvalue ...string) *string {
+	return CommandLine.EnumLong(name, short, values, value, helpvalue...)
+}
+
+func (s *Set) EnumLong(name string, short rune, values []string, value string, helpvalue ...string) *string {
+	var p enumValue
+	p.define(values, value, &option{short: short, long: name})
+	s.FlagLong(&p, name, short, helpvalue...)
+	return (*string)(&p)
+}
+
+func (e *enumValue) define(values []string, def string, opt Option) {
+	m := make(map[string]struct{})
+	for _, v := range values {
+		m[v] = struct{}{}
+	}
+	enumValuesMu.Lock()
+	enumValues[e] = m
+	enumValuesMu.Unlock()
+	if def != "" {
+		if err := e.Set(def, nil); err != nil {
+			fmt.Fprintf(stderr, "setting default for %s: %v\n", opt.Name(), err)
+			exit(1)
+		}
+	}
+}
diff --git a/vendor/github.com/pborman/getopt/v2/error.go b/vendor/github.com/pborman/getopt/v2/error.go
new file mode 100644
index 0000000..6f668a3
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/error.go
@@ -0,0 +1,93 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import "fmt"
+
+// An Error is returned by Getopt when it encounters an error.
+type Error struct {
+	ErrorCode        // General reason of failure.
+	Err       error  // The actual error.
+	Parameter string // Parameter passed to option, if any
+	Name      string // Option that cause error, if any
+}
+
+// Error returns the error message, implementing the error interface.
+func (i *Error) Error() string { return i.Err.Error() }
+
+// An ErrorCode indicates what sort of error was encountered.
+type ErrorCode int
+
+const (
+	NoError          = ErrorCode(iota)
+	UnknownOption    // an invalid option was encountered
+	MissingParameter // the options parameter is missing
+	ExtraParameter   // a value was set to a long flag
+	Invalid          // attempt to set an invalid value
+)
+
+func (e ErrorCode) String() string {
+	switch e {
+	case UnknownOption:
+		return "unknow option"
+	case MissingParameter:
+		return "missing argument"
+	case ExtraParameter:
+		return "unxpected value"
+	case Invalid:
+		return "error setting value"
+	}
+	return "unknown error"
+}
+
+// unknownOption returns an Error indicating an unknown option was
+// encountered.
+func unknownOption(name interface{}) *Error {
+	i := &Error{ErrorCode: UnknownOption}
+	switch n := name.(type) {
+	case rune:
+		if n == '-' {
+			i.Name = "-"
+		} else {
+			i.Name = "-" + string(n)
+		}
+	case string:
+		i.Name = "--" + n
+	}
+	i.Err = fmt.Errorf("unknown option: %s", i.Name)
+	return i
+}
+
+// missingArg returns an Error inidicating option o was not passed
+// a required paramter.
+func missingArg(o Option) *Error {
+	return &Error{
+		ErrorCode: MissingParameter,
+		Name:      o.Name(),
+		Err:       fmt.Errorf("missing parameter for %s", o.Name()),
+	}
+}
+
+// extraArg returns an Error inidicating option o was passed the
+// unexpected paramter value.
+func extraArg(o Option, value string) *Error {
+	return &Error{
+		ErrorCode: ExtraParameter,
+		Name:      o.Name(),
+		Parameter: value,
+		Err:       fmt.Errorf("unexpected parameter passed to %s: %q", o.Name(), value),
+	}
+}
+
+// setError returns an Error inidicating option o and the specified
+// error while setting it to value.
+func setError(o Option, value string, err error) *Error {
+	return &Error{
+		ErrorCode: Invalid,
+		Name:      o.Name(),
+		Parameter: value,
+		Err:       err,
+	}
+}
diff --git a/vendor/github.com/pborman/getopt/v2/generic.go b/vendor/github.com/pborman/getopt/v2/generic.go
new file mode 100644
index 0000000..c3c538e
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/generic.go
@@ -0,0 +1,238 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type generic struct {
+	p interface{}
+}
+
+// Flag is shorthand for CommandLine.Flag.
+func Flag(v interface{}, short rune, helpvalue ...string) Option {
+	return CommandLine.long(v, "", short, helpvalue...)
+}
+
+// FlagLong is shorthand for CommandLine.LongFlag.
+func FlagLong(v interface{}, long string, short rune, helpvalue ...string) Option {
+	return CommandLine.long(v, long, short, helpvalue...)
+}
+
+// Flag calls FlagLong with only a short flag name.
+func (s *Set) Flag(v interface{}, short rune, helpvalue ...string) Option {
+	return s.long(v, "", short, helpvalue...)
+}
+
+// FlagLong returns an Option in Set s for setting v.  If long is not "" then
+// the option has a long name, and if short is not 0, the option has a short
+// name.  v must either be of type getopt.Value or a pointer to one of the
+// supported builtin types:
+//
+//	bool, string, []string
+//	int, int8, int16, int32, int64
+//	uint, uint8, uint16, uint32, uint64
+//	float32, float64
+//	time.Duration
+//
+// FlagLong will panic if v is not a getopt.Value or one of the supported
+// builtin types.
+//
+// The default value of the flag is the value of v at the time FlagLong is
+// called.
+func (s *Set) FlagLong(v interface{}, long string, short rune, helpvalue ...string) Option {
+	return s.long(v, long, short, helpvalue...)
+}
+
+func (s *Set) long(v interface{}, long string, short rune, helpvalue ...string) (opt Option) {
+	// Fix up our location when we return.
+	if where := calledFrom(); where != "" {
+		defer func() {
+			if opt, ok := opt.(*option); ok {
+				opt.where = where
+			}
+		}()
+	}
+	switch p := v.(type) {
+	case Value:
+		return s.addFlag(p, long, short, helpvalue...)
+	case *bool:
+		return s.addFlag(&generic{v}, long, short, helpvalue...).SetFlag()
+	case *string, *[]string:
+		return s.addFlag(&generic{v}, long, short, helpvalue...)
+	case *int, *int8, *int16, *int32, *int64:
+		return s.addFlag(&generic{v}, long, short, helpvalue...)
+	case *uint, *uint8, *uint16, *uint32, *uint64:
+		return s.addFlag(&generic{v}, long, short, helpvalue...)
+	case *float32, *float64:
+		return s.addFlag(&generic{v}, long, short, helpvalue...)
+	case *time.Duration:
+		return s.addFlag(&generic{v}, long, short, helpvalue...)
+	default:
+		panic(fmt.Sprintf("unsupported flag type: %T", v))
+	}
+}
+
+func (g *generic) Set(value string, opt Option) error {
+	strconvErr := func(err error) error {
+		if e, ok := err.(*strconv.NumError); ok {
+			switch e.Err {
+			case strconv.ErrRange:
+				err = fmt.Errorf("value out of range: %s", value)
+			case strconv.ErrSyntax:
+				err = fmt.Errorf("not a valid number: %s", value)
+			}
+		}
+		return err
+	}
+	switch p := g.p.(type) {
+	case *bool:
+		switch strings.ToLower(value) {
+		case "", "1", "true", "on", "t":
+			*p = true
+		case "0", "false", "off", "f":
+			*p = false
+		default:
+			return fmt.Errorf("invalid value for bool %s: %q", opt.Name(), value)
+		}
+		return nil
+	case *string:
+		*p = value
+		return nil
+	case *[]string:
+		a := strings.Split(value, ",")
+		// If this is the first time we are seen then nil out the
+		// default value.
+		if opt.Count() <= 1 {
+			*p = nil
+		}
+		*p = append(*p, a...)
+		return nil
+	case *int:
+		i64, err := strconv.ParseInt(value, 0, strconv.IntSize)
+		if err == nil {
+			*p = int(i64)
+		}
+		return strconvErr(err)
+	case *int8:
+		i64, err := strconv.ParseInt(value, 0, 8)
+		if err == nil {
+			*p = int8(i64)
+		}
+		return strconvErr(err)
+	case *int16:
+		i64, err := strconv.ParseInt(value, 0, 16)
+		if err == nil {
+			*p = int16(i64)
+		}
+		return strconvErr(err)
+	case *int32:
+		i64, err := strconv.ParseInt(value, 0, 32)
+		if err == nil {
+			*p = int32(i64)
+		}
+		return strconvErr(err)
+	case *int64:
+		i64, err := strconv.ParseInt(value, 0, 64)
+		if err == nil {
+			*p = i64
+		}
+		return strconvErr(err)
+	case *uint:
+		u64, err := strconv.ParseUint(value, 0, strconv.IntSize)
+		if err == nil {
+			*p = uint(u64)
+		}
+		return strconvErr(err)
+	case *uint8:
+		u64, err := strconv.ParseUint(value, 0, 8)
+		if err == nil {
+			*p = uint8(u64)
+		}
+		return strconvErr(err)
+	case *uint16:
+		u64, err := strconv.ParseUint(value, 0, 16)
+		if err == nil {
+			*p = uint16(u64)
+		}
+		return strconvErr(err)
+	case *uint32:
+		u64, err := strconv.ParseUint(value, 0, 32)
+		if err == nil {
+			*p = uint32(u64)
+		}
+		return strconvErr(err)
+	case *uint64:
+		u64, err := strconv.ParseUint(value, 0, 64)
+		if err == nil {
+			*p = u64
+		}
+		return strconvErr(err)
+	case *float32:
+		f64, err := strconv.ParseFloat(value, 32)
+		if err == nil {
+			*p = float32(f64)
+		}
+		return strconvErr(err)
+	case *float64:
+		f64, err := strconv.ParseFloat(value, 64)
+		if err == nil {
+			*p = f64
+		}
+		return strconvErr(err)
+	case *time.Duration:
+		v, err := time.ParseDuration(value)
+		if err == nil {
+			*p = v
+		}
+		return err
+	}
+	panic("internal error")
+}
+
+func (g *generic) String() string {
+	switch p := g.p.(type) {
+	case *bool:
+		if *p {
+			return "true"
+		}
+		return "false"
+	case *string:
+		return *p
+	case *[]string:
+		return strings.Join([]string(*p), ",")
+	case *int:
+		return strconv.FormatInt(int64(*p), 10)
+	case *int8:
+		return strconv.FormatInt(int64(*p), 10)
+	case *int16:
+		return strconv.FormatInt(int64(*p), 10)
+	case *int32:
+		return strconv.FormatInt(int64(*p), 10)
+	case *int64:
+		return strconv.FormatInt(*p, 10)
+	case *uint:
+		return strconv.FormatUint(uint64(*p), 10)
+	case *uint8:
+		return strconv.FormatUint(uint64(*p), 10)
+	case *uint16:
+		return strconv.FormatUint(uint64(*p), 10)
+	case *uint32:
+		return strconv.FormatUint(uint64(*p), 10)
+	case *uint64:
+		return strconv.FormatUint(*p, 10)
+	case *float32:
+		return strconv.FormatFloat(float64(*p), 'g', -1, 32)
+	case *float64:
+		return strconv.FormatFloat(*p, 'g', -1, 64)
+	case *time.Duration:
+		return p.String()
+	}
+	panic("internal error")
+}
diff --git a/vendor/github.com/pborman/getopt/v2/getopt.go b/vendor/github.com/pborman/getopt/v2/getopt.go
new file mode 100644
index 0000000..0e3c51b
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/getopt.go
@@ -0,0 +1,534 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package getopt (v2) provides traditional getopt processing for implementing
+// commands that use traditional command lines.  The standard Go flag package
+// cannot be used to write a program that parses flags the way ls or ssh does,
+// for example.  Version 2 of this package has a simplified API.
+//
+// See the github.com/pborman/options package for a simple structure based
+// interface to this package.
+//
+// USAGE
+//
+// Getopt supports functionality found in both the standard BSD getopt as well
+// as (one of the many versions of) the GNU getopt_long.  Being a Go package,
+// this package makes common usage easy, but still enables more controlled usage
+// if needed.
+//
+// Typical usage:
+//
+//	// Declare flags and have getopt return pointers to the values.
+//	helpFlag := getopt.Bool('?', "display help")
+//	cmdFlag := getopt.StringLong("command", 'c', "default", "the command")
+//
+//	// Declare flags against existing variables.
+//	var {
+//		fileName = "/the/default/path"
+//		timeout = time.Second * 5
+//		verbose bool
+//	}
+//	func init() {
+//		getopt.Flag(&verbose, 'v', "be verbose")
+//		getopt.FlagLong(&fileName, "path", 0, "the path")
+//		getopt.FlagLong(&timeout, "timeout", 't', "some timeout")
+//	}
+//
+//	func main() {
+//		// Parse the program arguments
+//		getopt.Parse()
+//		// Get the remaining positional parameters
+//		args := getopt.Args()
+//		...
+//
+// If you don't want the program to exit on error, use getopt.Getopt:
+//
+//		err := getopt.Getopt(nil)
+//		if err != nil {
+//			// code to handle error
+//			fmt.Fprintln(os.Stderr, err)
+//		}
+//
+// FLAG SYNTAX
+//
+// Support is provided for both short (-f) and long (--flag) options.  A single
+// option may have both a short and a long name.  Each option may be a flag or a
+// value.  A value takes an argument.
+//
+// Declaring no long names causes this package to process arguments like the
+// traditional BSD getopt.
+//
+// Short flags may be combined into a single parameter.  For example, "-a -b -c"
+// may also be expressed "-abc".  Long flags must stand on their own "--alpha
+// --beta"
+//
+// Values require an argument.  For short options the argument may either be
+// immediately following the short name or as the next argument.  Only one short
+// value may be combined with short flags in a single argument; the short value
+// must be after all short flags.  For example, if f is a flag and v is a value,
+// then:
+//
+//  -vvalue    (sets v to "value")
+//  -v value   (sets v to "value")
+//  -fvvalue   (sets f, and sets v to "value")
+//  -fv value  (sets f, and sets v to "value")
+//  -vf value  (set v to "f" and value is the first parameter)
+//
+// For the long value option val:
+//
+//  --val value (sets val to "value")
+//  --val=value (sets val to "value")
+//  --valvalue  (invalid option "valvalue")
+//
+// Values with an optional value only set the value if the value is part of the
+// same argument.  In any event, the option count is increased and the option is
+// marked as seen.
+//
+//  -v -f          (sets v and f as being seen)
+//  -vvalue -f     (sets v to "value" and sets f)
+//  --val -f       (sets v and f as being seen)
+//  --val=value -f (sets v to "value" and sets f)
+//
+// There is no convenience function defined for making the value optional.  The
+// SetOptional method must be called on the actual Option.
+//
+//  v := String("val", 'v', "", "the optional v")
+//  Lookup("v").SetOptional()
+//
+//  var s string
+//  FlagLong(&s, "val", 'v', "the optional v).SetOptional()
+//
+// Parsing continues until the first non-option or "--" is encountered.
+//
+// The short name "-" can be used, but it either is specified as "-" or as part
+// of a group of options, for example "-f-".  If there are no long options
+// specified then "--f" could also be used.  If "-" is not declared as an option
+// then the single "-" will also terminate the option processing but unlike
+// "--", the "-" will be part of the remaining arguments.
+//
+// ADVANCED USAGE
+//
+// Normally the parsing is performed by calling the Parse function.  If it is
+// important to see the order of the options then the Getopt function should be
+// used.  The standard Parse function does the equivalent of:
+//
+// func Parse() {
+//	if err := getopt.Getopt(os.Args, nil); err != nil {
+//		fmt.Fprintln(os.Stderr, err)
+//		s.usage()
+//		os.Exit(1)
+//	}
+//
+// When calling Getopt it is the responsibility of the caller to print any
+// errors.
+//
+// Normally the default option set, CommandLine, is used.  Other option sets may
+// be created with New.
+//
+// After parsing, the sets Args will contain the non-option arguments.  If an
+// error is encountered then Args will begin with argument that caused the
+// error.
+//
+// It is valid to call a set's Parse a second time to amen flags or values.  As
+// an example:
+//
+//  var a = getopt.Bool('a', "", "The a flag")
+//  var b = getopt.Bool('b', "", "The a flag")
+//  var cmd = ""
+//
+//  var opts = getopt.CommandLine
+//
+//  opts.Parse(os.Args)
+//  if opts.NArgs() > 0 {
+//      cmd = opts.Arg(0)
+//      opts.Parse(opts.Args())
+//  }
+//
+// If called with set to { "prog", "-a", "cmd", "-b", "arg" } then both and and
+// b would be set, cmd would be set to "cmd", and opts.Args() would return {
+// "arg" }.
+//
+// Unless an option type explicitly prohibits it, an option may appear more than
+// once in the arguments.  The last value provided to the option is the value.
+//
+// BUILTIN TYPES
+//
+// The Flag and FlagLong functions support most standard Go types.  For the
+// list, see the description of FlagLong below for a list of supported types.
+//
+// There are also helper routines to allow single line flag declarations.  These
+// types are: Bool, Counter, Duration, Enum, Int16, Int32, Int64, Int, List,
+// Signed, String, Uint16, Uint32, Uint64, Uint, and Unsigned.
+//
+// Each comes in a short and long flavor, e.g., Bool and BoolLong and include
+// functions to set the flags on the standard command line or for a specific Set
+// of flags.
+//
+// Except for the Counter, Enum, Signed and Unsigned types, all of these types
+// can be declared using Flag and FlagLong by passing in a pointer to the
+// appropriate type.
+//
+// DECLARING NEW FLAG TYPES
+//
+// A pointer to any type that implements the Value interface may be passed to
+// Flag or FlagLong.
+//
+// VALUEHELP
+//
+// All non-flag options are created with a "valuehelp" as the last parameter.
+// Valuehelp should be 0, 1, or 2 strings.  The first string, if provided, is
+// the usage message for the option.  If the second string, if provided, is the
+// name to use for the value when displaying the usage.  If not provided the
+// term "value" is assumed.
+//
+// The usage message for the option created with
+//
+//  StringLong("option", 'o', "defval", "a string of letters")
+//
+// is
+//
+//  -o, -option=value
+//
+//  StringLong("option", 'o', "defval", "a string of letters", "string")
+//
+// is
+//
+//  -o, -option=string
+package getopt
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"sort"
+	"strings"
+)
+
+// stderr allows tests to capture output to standard error.
+var stderr io.Writer = os.Stderr
+
+// exit allows tests to capture an os.Exit call
+var exit = os.Exit
+
+// DisplayWidth is used to determine where to split usage long lines.
+var DisplayWidth = 80
+
+// HelpColumn is the maximum column position that help strings start to display
+// at.  If the option usage is too long then the help string will be displayed
+// on the next line.  For example:
+//
+//   -a   this is the a flag
+//   -u, --under=location
+//        the u flag's usage is quite long
+var HelpColumn = 20
+
+// PrintUsage prints the usage line and set of options of set S to w.
+func (s *Set) PrintUsage(w io.Writer) {
+	parts := make([]string, 2, 4)
+	parts[0] = "Usage:"
+	parts[1] = s.program
+	if usage := s.UsageLine(); usage != "" {
+		parts = append(parts, usage)
+	}
+	if s.parameters != "" {
+		parts = append(parts, s.parameters)
+	}
+	fmt.Fprintln(w, strings.Join(parts, " "))
+	s.PrintOptions(w)
+}
+
+// UsageLine returns the usage line for the set s.  The set's program name and
+// parameters, if any, are not included.
+func (s *Set) UsageLine() string {
+	sort.Sort(s.options)
+	flags := ""
+
+	// Build up the list of short flag names and also compute
+	// how to display the option in the longer help listing.
+	// We also keep track of the longest option usage string
+	// that is no more than HelpColumn-3 bytes (at which point
+	// we use two lines to display the help).  The three
+	// is for the leading space and the two spaces before the
+	// help string.
+	for _, opt := range s.options {
+		if opt.name == "" {
+			opt.name = "value"
+		}
+		if opt.uname == "" {
+			opt.uname = opt.usageName()
+		}
+		if opt.flag && opt.short != 0 && opt.short != '-' {
+			flags += string(opt.short)
+		}
+	}
+
+	var opts []string
+
+	// The short option - is special
+	if s.shortOptions['-'] != nil {
+		opts = append(opts, "-")
+	}
+
+	// If we have a bundle of flags, add them to the list
+	if flags != "" {
+		opts = append(opts, "-"+flags)
+	}
+
+	// Now append all the long options and options that require
+	// values.
+	for _, opt := range s.options {
+		if opt.flag {
+			if opt.short != 0 {
+				continue
+			}
+			flags = "--" + opt.long
+		} else if opt.short != 0 {
+			flags = "-" + string(opt.short) + " " + opt.name
+		} else {
+			flags = "--" + string(opt.long) + " " + opt.name
+		}
+		opts = append(opts, flags)
+	}
+	flags = strings.Join(opts, "] [")
+	if flags != "" {
+		flags = "[" + flags + "]"
+	}
+	return flags
+}
+
+// PrintOptions prints the list of options in s to w.
+func (s *Set) PrintOptions(w io.Writer) {
+	sort.Sort(s.options)
+	max := 4
+	for _, opt := range s.options {
+		if opt.name == "" {
+			opt.name = "value"
+		}
+		if opt.uname == "" {
+			opt.uname = opt.usageName()
+		}
+		if max < len(opt.uname) && len(opt.uname) <= HelpColumn-3 {
+			max = len(opt.uname)
+		}
+	}
+	// Now print one or more usage lines per option.
+	for _, opt := range s.options {
+		if opt.uname != "" {
+			opt.help = strings.TrimSpace(opt.help)
+			if len(opt.help) == 0 {
+				fmt.Fprintf(w, " %s\n", opt.uname)
+				continue
+			}
+			help := strings.Split(opt.help, "\n")
+			// If they did not put in newlines then we will insert
+			// them to keep the help messages from wrapping.
+			if len(help) == 1 {
+				help = breakup(help[0], DisplayWidth-HelpColumn)
+			}
+			if len(opt.uname) <= max {
+				fmt.Fprintf(w, " %-*s  %s\n", max, opt.uname, help[0])
+				help = help[1:]
+			} else {
+				fmt.Fprintf(w, " %s\n", opt.uname)
+			}
+			for _, s := range help {
+				fmt.Fprintf(w, " %-*s  %s\n", max, " ", s)
+			}
+		}
+	}
+}
+
+// breakup breaks s up into strings no longer than max bytes.
+func breakup(s string, max int) []string {
+	var a []string
+
+	for {
+		// strip leading spaces
+		for len(s) > 0 && s[0] == ' ' {
+			s = s[1:]
+		}
+		// If the option is no longer than the max just return it
+		if len(s) <= max {
+			if len(s) != 0 {
+				a = append(a, s)
+			}
+			return a
+		}
+		x := max
+		for s[x] != ' ' {
+			// the first word is too long?!
+			if x == 0 {
+				x = max
+				for x < len(s) && s[x] != ' ' {
+					x++
+				}
+				if x == len(s) {
+					x--
+				}
+				break
+			}
+			x--
+		}
+		for s[x] == ' ' {
+			x--
+		}
+		a = append(a, s[:x+1])
+		s = s[x+1:]
+	}
+}
+
+// Parse uses Getopt to parse args using the options set for s.  The first
+// element of args is used to assign the program for s if it is not yet set.  On
+// error, Parse displays the error message as well as a usage message on
+// standard error and then exits the program.
+func (s *Set) Parse(args []string) {
+	if err := s.Getopt(args, nil); err != nil {
+		fmt.Fprintln(stderr, err)
+		s.usage()
+		exit(1)
+	}
+}
+
+// Parse uses Getopt to parse args using the options set for s.  The first
+// element of args is used to assign the program for s if it is not yet set.
+// Getop calls fn, if not nil, for each option parsed.
+//
+// Getopt returns nil when all options have been processed (a non-option
+// argument was encountered, "--" was encountered, or fn returned false).
+//
+// On error getopt returns a reference to an InvalidOption (which implements the
+// error interface).
+func (s *Set) Getopt(args []string, fn func(Option) bool) (err error) {
+	s.setState(InProgress)
+	defer func() {
+		if s.State() == InProgress {
+			switch {
+			case err != nil:
+				s.setState(Failure)
+			case len(s.args) == 0:
+				s.setState(EndOfArguments)
+			default:
+				s.setState(Unknown)
+			}
+		}
+	}()
+	if fn == nil {
+		fn = func(Option) bool { return true }
+	}
+	if len(args) == 0 {
+		return nil
+	}
+
+	if s.program == "" {
+		s.program = path.Base(args[0])
+	}
+	args = args[1:]
+Parsing:
+	for len(args) > 0 {
+		arg := args[0]
+		s.args = args
+		args = args[1:]
+
+		// end of options?
+		if arg == "" || arg[0] != '-' {
+			s.setState(EndOfOptions)
+			return nil
+		}
+
+		if arg == "-" {
+			goto ShortParsing
+		}
+
+		// explicitly request end of options?
+		if arg == "--" {
+			s.args = args
+			s.setState(DashDash)
+			return nil
+		}
+
+		// Long option processing
+		if len(s.longOptions) > 0 && arg[1] == '-' {
+			e := strings.IndexRune(arg, '=')
+			var value string
+			if e > 0 {
+				value = arg[e+1:]
+				arg = arg[:e]
+			}
+			opt := s.longOptions[arg[2:]]
+			// If we are processing long options then --f is -f
+			// if f is not defined as a long option.
+			// This lets you say --f=false
+			if opt == nil && len(arg[2:]) == 1 {
+				opt = s.shortOptions[rune(arg[2])]
+			}
+			if opt == nil {
+				return unknownOption(arg[2:])
+			}
+			opt.isLong = true
+			// If we require an option and did not have an =
+			// then use the next argument as an option.
+			if !opt.flag && e < 0 && !opt.optional {
+				if len(args) == 0 {
+					return missingArg(opt)
+				}
+				value = args[0]
+				args = args[1:]
+			}
+			opt.count++
+
+			if err := opt.value.Set(value, opt); err != nil {
+				return setError(opt, value, err)
+			}
+
+			if !fn(opt) {
+				s.setState(Terminated)
+				return nil
+			}
+			continue Parsing
+		}
+
+		// Short option processing
+		arg = arg[1:] // strip -
+	ShortParsing:
+		for i, c := range arg {
+			opt := s.shortOptions[c]
+			if opt == nil {
+				// In traditional getopt, if - is not registered
+				// as an option, a lone - is treated as
+				// if there were a -- in front of it.
+				if arg == "-" {
+					s.setState(Dash)
+					return nil
+				}
+				return unknownOption(c)
+			}
+			opt.isLong = false
+			opt.count++
+			var value string
+			if !opt.flag {
+				value = arg[1+i:]
+				if value == "" && !opt.optional {
+					if len(args) == 0 {
+						return missingArg(opt)
+					}
+					value = args[0]
+					args = args[1:]
+				}
+			}
+			if err := opt.value.Set(value, opt); err != nil {
+				return setError(opt, value, err)
+			}
+			if !fn(opt) {
+				s.setState(Terminated)
+				return nil
+			}
+			if !opt.flag {
+				continue Parsing
+			}
+		}
+	}
+	s.args = []string{}
+	return nil
+}
diff --git a/vendor/github.com/pborman/getopt/v2/int.go b/vendor/github.com/pborman/getopt/v2/int.go
new file mode 100644
index 0000000..42833c1
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/int.go
@@ -0,0 +1,157 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+// Int creates an option that parses its value as an integer.
+func Int(name rune, value int, helpvalue ...string) *int {
+	return CommandLine.Int(name, value, helpvalue...)
+}
+
+func (s *Set) Int(name rune, value int, helpvalue ...string) *int {
+	s.Flag(&value, name, helpvalue...)
+	return &value
+}
+
+func IntLong(name string, short rune, value int, helpvalue ...string) *int {
+	return CommandLine.IntLong(name, short, value, helpvalue...)
+}
+
+func (s *Set) IntLong(name string, short rune, value int, helpvalue ...string) *int {
+	s.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
+
+// Int16 creates an option that parses its value as a 16 bit integer.
+func Int16(name rune, value int16, helpvalue ...string) *int16 {
+	return CommandLine.Int16(name, value, helpvalue...)
+}
+
+func (s *Set) Int16(name rune, value int16, helpvalue ...string) *int16 {
+	s.Flag(&value, name, helpvalue...)
+	return &value
+}
+
+func Int16Long(name string, short rune, value int16, helpvalue ...string) *int16 {
+	return CommandLine.Int16Long(name, short, value, helpvalue...)
+}
+
+func (s *Set) Int16Long(name string, short rune, value int16, helpvalue ...string) *int16 {
+	s.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
+
+// Int32 creates an option that parses its value as a 32 bit integer.
+func Int32(name rune, value int32, helpvalue ...string) *int32 {
+	return CommandLine.Int32(name, value, helpvalue...)
+}
+
+func (s *Set) Int32(name rune, value int32, helpvalue ...string) *int32 {
+	s.Flag(&value, name, helpvalue...)
+	return &value
+}
+
+func Int32Long(name string, short rune, value int32, helpvalue ...string) *int32 {
+	return CommandLine.Int32Long(name, short, value, helpvalue...)
+}
+
+func (s *Set) Int32Long(name string, short rune, value int32, helpvalue ...string) *int32 {
+	s.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
+
+// Int64 creates an option that parses its value as a 64 bit integer.
+func Int64(name rune, value int64, helpvalue ...string) *int64 {
+	return CommandLine.Int64(name, value, helpvalue...)
+}
+
+func (s *Set) Int64(name rune, value int64, helpvalue ...string) *int64 {
+	s.Flag(&value, name, helpvalue...)
+	return &value
+}
+
+func Int64Long(name string, short rune, value int64, helpvalue ...string) *int64 {
+	return CommandLine.Int64Long(name, short, value, helpvalue...)
+}
+
+func (s *Set) Int64Long(name string, short rune, value int64, helpvalue ...string) *int64 {
+	s.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
+
+// Uint creates an option that parses its value as an unsigned integer.
+func Uint(name rune, value uint, helpvalue ...string) *uint {
+	return CommandLine.Uint(name, value, helpvalue...)
+}
+
+func (s *Set) Uint(name rune, value uint, helpvalue ...string) *uint {
+	s.Flag(&value, name, helpvalue...)
+	return &value
+}
+
+func UintLong(name string, short rune, value uint, helpvalue ...string) *uint {
+	return CommandLine.UintLong(name, short, value, helpvalue...)
+}
+
+func (s *Set) UintLong(name string, short rune, value uint, helpvalue ...string) *uint {
+	s.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
+
+// Uint16 creates an option that parses its value as a 16 bit unsigned integer.
+func Uint16(name rune, value uint16, helpvalue ...string) *uint16 {
+	return CommandLine.Uint16(name, value, helpvalue...)
+}
+
+func (s *Set) Uint16(name rune, value uint16, helpvalue ...string) *uint16 {
+	s.Flag(&value, name, helpvalue...)
+	return &value
+}
+
+func Uint16Long(name string, short rune, value uint16, helpvalue ...string) *uint16 {
+	return CommandLine.Uint16Long(name, short, value, helpvalue...)
+}
+
+func (s *Set) Uint16Long(name string, short rune, value uint16, helpvalue ...string) *uint16 {
+	s.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
+
+// Uint32 creates an option that parses its value as a 32 bit unsigned integer.
+func Uint32(name rune, value uint32, helpvalue ...string) *uint32 {
+	return CommandLine.Uint32(name, value, helpvalue...)
+}
+
+func (s *Set) Uint32(name rune, value uint32, helpvalue ...string) *uint32 {
+	s.Flag(&value, name, helpvalue...)
+	return &value
+}
+
+func Uint32Long(name string, short rune, value uint32, helpvalue ...string) *uint32 {
+	return CommandLine.Uint32Long(name, short, value, helpvalue...)
+}
+
+func (s *Set) Uint32Long(name string, short rune, value uint32, helpvalue ...string) *uint32 {
+	s.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
+
+// Uint64 creates an option that parses its value as a 64 bit unsigned integer.
+func Uint64(name rune, value uint64, helpvalue ...string) *uint64 {
+	return CommandLine.Uint64(name, value, helpvalue...)
+}
+
+func (s *Set) Uint64(name rune, value uint64, helpvalue ...string) *uint64 {
+	s.Flag(&value, name, helpvalue...)
+	return &value
+}
+
+func Uint64Long(name string, short rune, value uint64, helpvalue ...string) *uint64 {
+	return CommandLine.Uint64Long(name, short, value, helpvalue...)
+}
+
+func (s *Set) Uint64Long(name string, short rune, value uint64, helpvalue ...string) *uint64 {
+	s.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
diff --git a/vendor/github.com/pborman/getopt/v2/list.go b/vendor/github.com/pborman/getopt/v2/list.go
new file mode 100644
index 0000000..99a09ef
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/list.go
@@ -0,0 +1,32 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+// List creates an option that returns a slice of strings.  The parameters
+// passed are converted from a comma separated value list into a slice.
+// Subsequent occurrences append to the list.
+func List(name rune, helpvalue ...string) *[]string {
+	p := []string{}
+	CommandLine.Flag(&p, name, helpvalue...)
+	return &p
+}
+
+func (s *Set) List(name rune, helpvalue ...string) *[]string {
+	p := []string{}
+	s.Flag(&p, name, helpvalue...)
+	return &p
+}
+
+func ListLong(name string, short rune, helpvalue ...string) *[]string {
+	p := []string{}
+	CommandLine.FlagLong(&p, name, short, helpvalue...)
+	return &p
+}
+
+func (s *Set) ListLong(name string, short rune, helpvalue ...string) *[]string {
+	p := []string{}
+	s.FlagLong(&p, name, short, helpvalue...)
+	return &p
+}
diff --git a/vendor/github.com/pborman/getopt/v2/option.go b/vendor/github.com/pborman/getopt/v2/option.go
new file mode 100644
index 0000000..67822bc
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/option.go
@@ -0,0 +1,212 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import (
+	"fmt"
+	"strings"
+)
+
+// An Option can be either a Flag or a Value
+type Option interface {
+	// Name returns the name of the option.  If the option has been seen
+	// then the last way it was referenced (short or long) is returned
+	// otherwise if there is a short name then this will be the short name
+	// as a string, else it will be the long name.
+	Name() string
+
+	// ShortName always returns the short name of the option, or "" if there
+	// is no short name.  The name does not include the "-".
+	ShortName() string
+
+	// LongName always returns the long name of the option, or "" if there
+	// is no long name.  The name does not include the "--".
+	LongName() string
+
+	// IsFlag returns true if Option is a flag.
+	IsFlag() bool
+
+	// Seen returns true if the flag was seen.
+	Seen() bool
+
+	// Count returns the number of times the flag was seen.
+	Count() int
+
+	// String returns the last value the option was set to.
+	String() string
+
+	// Value returns the Value of the option.
+	Value() Value
+
+	// SetOptional makes the value optional.  The option and value are
+	// always a single argument.  Either --option or --option=value.  In
+	// the former case the value of the option does not change but the Set()
+	// will return true and the value returned by Count() is incremented.
+	// The short form is either -o or -ovalue.  SetOptional returns
+	// the Option
+	SetOptional() Option
+
+	// SetFlag makes the value a flag.  Flags are boolean values and
+	// normally do not taken a value.  They are set to true when seen.
+	// If a value is passed in the long form then it must be on, case
+	// insensitivinsensitive, one of "true", "false", "t", "f", "on", "off", "1", "0".
+	// SetFlag returns the Option
+	SetFlag() Option
+
+	// Reset resets the state of the option so it appears it has not
+	// yet been seen, including resetting the value of the option
+	// to its original default state.
+	Reset()
+}
+
+type option struct {
+	short    rune   // 0 means no short name
+	long     string // "" means no long name
+	isLong   bool   // True if they used the long name
+	flag     bool   // true if a boolean flag
+	defval   string // default value
+	optional bool   // true if we take an optional value
+	help     string // help message
+	where    string // file where the option was defined
+	value    Value  // current value of option
+	count    int    // number of times we have seen this option
+	name     string // name of the value (for usage)
+	uname    string // name of the option (for usage)
+}
+
+// usageName returns the name of the option for printing usage lines in one
+// of the following forms:
+//
+//  -f
+//      --flag
+//  -f, --flag
+//  -s value
+//      --set=value
+//  -s, --set=value
+func (o *option) usageName() string {
+	// Don't print help messages if we have none and there is only one
+	// way to specify the option.
+	if o.help == "" && (o.short == 0 || o.long == "") {
+		return ""
+	}
+	n := ""
+
+	switch {
+	case o.short != 0 && o.long == "":
+		n = "-" + string(o.short)
+	case o.short == 0 && o.long != "":
+		n = "    --" + o.long
+	case o.short != 0 && o.long != "":
+		n = "-" + string(o.short) + ", --" + o.long
+	}
+
+	switch {
+	case o.flag:
+		return n
+	case o.optional:
+		return n + "[=" + o.name + "]"
+	case o.long != "":
+		return n + "=" + o.name
+	}
+	return n + " " + o.name
+}
+
+// sortName returns the name to sort the option on.
+func (o *option) sortName() string {
+	if o.short != 0 {
+		return string(o.short) + o.long
+	}
+	return o.long[:1] + o.long
+}
+
+func (o *option) Seen() bool          { return o.count > 0 }
+func (o *option) Count() int          { return o.count }
+func (o *option) IsFlag() bool        { return o.flag }
+func (o *option) String() string      { return o.value.String() }
+func (o *option) SetOptional() Option { o.optional = true; return o }
+func (o *option) SetFlag() Option     { o.flag = true; return o }
+
+func (o *option) Value() Value {
+	if o == nil {
+		return nil
+	}
+	return o.value
+}
+
+func (o *option) Name() string {
+	if !o.isLong && o.short != 0 {
+		return "-" + string(o.short)
+	}
+	return "--" + o.long
+}
+
+func (o *option) ShortName() string {
+	if o.short != 0 {
+		return string(o.short)
+	}
+	return ""
+}
+
+func (o *option) LongName() string {
+	return o.long
+}
+
+// Reset rests an option so that it appears it has not yet been seen.
+func (o *option) Reset() {
+	o.isLong = false
+	o.count = 0
+	o.value.Set(o.defval, o)
+}
+
+type optionList []*option
+
+func (ol optionList) Len() int      { return len(ol) }
+func (ol optionList) Swap(i, j int) { ol[i], ol[j] = ol[j], ol[i] }
+func (ol optionList) Less(i, j int) bool {
+	// first check the short names (or the first letter of the long name)
+	// If they are not equal (case insensitive) then we have our answer
+	n1 := ol[i].sortName()
+	n2 := ol[j].sortName()
+	l1 := strings.ToLower(n1)
+	l2 := strings.ToLower(n2)
+	if l1 < l2 {
+		return true
+	}
+	if l2 < l1 {
+		return false
+	}
+	return n1 < n2
+}
+
+// AddOption add the option o to set CommandLine if o is not already in set
+// CommandLine.
+func AddOption(o Option) {
+	CommandLine.AddOption(o)
+}
+
+// AddOption add the option o to set s if o is not already in set s.
+func (s *Set) AddOption(o Option) {
+	opt := o.(*option)
+	for _, eopt := range s.options {
+		if opt == eopt {
+			return
+		}
+	}
+	if opt.short != 0 {
+		if oo, ok := s.shortOptions[opt.short]; ok {
+			fmt.Fprintf(stderr, "%s: -%c already declared at %s\n", opt.where, opt.short, oo.where)
+			exit(1)
+		}
+		s.shortOptions[opt.short] = opt
+	}
+	if opt.long != "" {
+		if oo, ok := s.longOptions[opt.long]; ok {
+			fmt.Fprintf(stderr, "%s: --%s already declared at %s\n", opt.where, opt.long, oo.where)
+			exit(1)
+		}
+		s.longOptions[opt.long] = opt
+	}
+	s.options = append(s.options, opt)
+}
diff --git a/vendor/github.com/pborman/getopt/v2/set.go b/vendor/github.com/pborman/getopt/v2/set.go
new file mode 100644
index 0000000..6302ab7
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/set.go
@@ -0,0 +1,291 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import (
+	"io"
+	"os"
+	"sort"
+	"sync"
+)
+
+// A State is why the Getopt returned.
+type State int
+
+const (
+	InProgress     = State(iota) // Getopt is still running
+	Dash                         // Returned on "-"
+	DashDash                     // Returned on "--"
+	EndOfOptions                 // End of options reached
+	EndOfArguments               // No more arguments
+	Terminated                   // Terminated by callback function
+	Failure                      // Terminated due to error
+	Unknown                      // Indicates internal error
+)
+
+type Set struct {
+	stateMu sync.Mutex
+	state   State
+
+	// args are the parameters remaining after parsing the optoins.
+	args []string
+
+	// program is the name of the program for usage and error messages.
+	// If not set it will automatically be set to the base name of the
+	// first argument passed to parse.
+	program string
+
+	// parameters is what is displayed on the usage line after displaying
+	// the various options.
+	parameters string
+
+	usage func() // usage should print the programs usage and exit.
+
+	shortOptions map[rune]*option
+	longOptions  map[string]*option
+	options      optionList
+}
+
+// New returns a newly created option set.
+func New() *Set {
+	s := &Set{
+		shortOptions: make(map[rune]*option),
+		longOptions:  make(map[string]*option),
+		parameters:   "[parameters ...]",
+	}
+
+	s.usage = func() {
+		s.PrintUsage(stderr)
+	}
+	return s
+}
+
+func (s *Set) setState(state State) {
+	s.stateMu.Lock()
+	s.state = state
+	s.stateMu.Unlock()
+}
+
+// State returns the current state of the Set s.  The state is normally the
+// reason the most recent call to Getopt returned.
+func (s *Set) State() State {
+	s.stateMu.Lock()
+	defer s.stateMu.Unlock()
+	return s.state
+}
+
+// The default set of command-line options.
+var CommandLine = New()
+
+// PrintUsage calls PrintUsage in the default option set.
+func PrintUsage(w io.Writer) { CommandLine.PrintUsage(w) }
+
+// Usage calls the usage function in the default option set.
+func Usage() { CommandLine.usage() }
+
+// Parse calls Parse in the default option set with the command line arguments
+// found in os.Args.
+func Parse() { CommandLine.Parse(os.Args) }
+
+// Getops returns the result of calling Getop in the default option set with the
+// command line arguments found in os.Args.  The fn function, which may be nil,
+// is passed to Getopt.
+func Getopt(fn func(Option) bool) error { return CommandLine.Getopt(os.Args, fn) }
+
+// Arg returns the n'th command-line argument. Arg(0) is the first remaining
+// argument after options have been processed.
+func Arg(n int) string {
+	if n >= 0 && n < len(CommandLine.args) {
+		return CommandLine.args[n]
+	}
+	return ""
+}
+
+// Arg returns the n'th argument. Arg(0) is the first remaining
+// argument after options have been processed.
+func (s *Set) Arg(n int) string {
+	if n >= 0 && n < len(s.args) {
+		return s.args[n]
+	}
+	return ""
+}
+
+// Args returns the non-option command line arguments.
+func Args() []string {
+	return CommandLine.args
+}
+
+// Args returns the non-option arguments.
+func (s *Set) Args() []string {
+	return s.args
+}
+
+// NArgs returns the number of non-option command line arguments.
+func NArgs() int {
+	return len(CommandLine.args)
+}
+
+// NArgs returns the number of non-option arguments.
+func (s *Set) NArgs() int {
+	return len(s.args)
+}
+
+// SetParameters sets the parameters string for printing the command line
+// usage.  It defaults to "[parameters ...]"
+func SetParameters(parameters string) {
+	CommandLine.parameters = parameters
+}
+
+// SetParameters sets the parameters string for printing the s's usage.
+// It defaults to "[parameters ...]"
+func (s *Set) SetParameters(parameters string) {
+	s.parameters = parameters
+}
+
+// Parameters returns the parameters set by SetParameters on s.
+func (s *Set) Parameters() string { return s.parameters }
+
+
+// SetProgram sets the program name to program.  Normally it is determined
+// from the zeroth command line argument (see os.Args).
+func SetProgram(program string) {
+	CommandLine.program = program
+}
+
+// SetProgram sets s's program name to program.  Normally it is determined
+// from the zeroth argument passed to Getopt or Parse.
+func (s *Set) SetProgram(program string) {
+	s.program = program
+}
+
+// Program returns the program name associated with Set s.
+func (s *Set) Program() string { return s.program }
+
+// SetUsage sets the function used by Parse to display the commands usage
+// on error.  It defaults to calling PrintUsage(os.Stderr).
+func SetUsage(usage func()) {
+	CommandLine.usage = usage
+}
+
+// SetUsage sets the function used by Parse to display usage on error.  It
+// defaults to calling f.PrintUsage(os.Stderr).
+func (s *Set) SetUsage(usage func()) {
+	s.usage = usage
+}
+
+// Lookup returns the Option associated with name.  Name should either be
+// a rune (the short name) or a string (the long name).
+func Lookup(name interface{}) Option {
+	return CommandLine.Lookup(name)
+}
+
+// Lookup returns the Option associated with name in s.  Name should either be
+// a rune (the short name) or a string (the long name).
+func (s *Set) Lookup(name interface{}) Option {
+	switch v := name.(type) {
+	case rune:
+		return s.shortOptions[v]
+	case int:
+		return s.shortOptions[rune(v)]
+	case string:
+		return s.longOptions[v]
+	}
+	return nil
+}
+
+// IsSet returns true if the Option associated with name was seen while
+// parsing the command line arguments.  Name should either be a rune (the
+// short name) or a string (the long name).
+func IsSet(name interface{}) bool {
+	return CommandLine.IsSet(name)
+}
+
+// IsSet returns true if the Option associated with name was seen while
+// parsing s.  Name should either be a rune (the short name) or a string (the
+// long name).
+func (s *Set) IsSet(name interface{}) bool {
+	if opt := s.Lookup(name); opt != nil {
+		return opt.Seen()
+	}
+	return false
+}
+
+// GetCount returns the number of times the Option associated with name has been
+// seen while parsing the command line arguments.  Name should either be a rune
+// (the short name) or a string (the long name).
+func GetCount(name interface{}) int {
+	return CommandLine.GetCount(name)
+}
+
+// GetCount returns the number of times the Option associated with name has been
+// seen while parsing s's arguments.  Name should either be a rune (the short
+// name) or a string (the long name).
+func (s *Set) GetCount(name interface{}) int {
+	if opt := s.Lookup(name); opt != nil {
+		return opt.Count()
+	}
+	return 0
+}
+
+// GetValue returns the final value set to the command-line Option with name.
+// If the option has not been seen while parsing s then the default value is
+// returned.  Name should either be a rune (the short name) or a string (the
+// long name).
+func GetValue(name interface{}) string {
+	return CommandLine.GetValue(name)
+}
+
+// GetValue returns the final value set to the Option in s associated with name.
+// If the option has not been seen while parsing s then the default value is
+// returned.  Name should either be a rune (the short name) or a string (the
+// long name).
+func (s *Set) GetValue(name interface{}) string {
+	if opt := s.Lookup(name); opt != nil {
+		return opt.String()
+	}
+	return ""
+}
+
+// Visit visits the command-line options in lexicographical order, calling fn
+// for each. It visits only those options that have been set.
+func Visit(fn func(Option)) { CommandLine.Visit(fn) }
+
+// Visit visits the options in s in lexicographical order, calling fn
+// for each. It visits only those options that have been set.
+func (s *Set) Visit(fn func(Option)) {
+	sort.Sort(s.options)
+	for _, opt := range s.options {
+		if opt.count > 0 {
+			fn(opt)
+		}
+	}
+}
+
+// VisitAll visits the options in s in lexicographical order, calling fn
+// for each. It visits all options, even those not set.
+func VisitAll(fn func(Option)) { CommandLine.VisitAll(fn) }
+
+// VisitAll visits the command-line flags in lexicographical order, calling fn
+// for each. It visits all flags, even those not set.
+func (s *Set) VisitAll(fn func(Option)) {
+	sort.Sort(s.options)
+	for _, opt := range s.options {
+		fn(opt)
+	}
+}
+
+// Reset resets all the command line options to the initial state so it
+// appears none of them have been seen.
+func Reset() {
+	CommandLine.Reset()
+}
+
+// Reset resets all the options in s to the initial state so it
+// appears none of them have been seen.
+func (s *Set) Reset() {
+	for _, opt := range s.options {
+		opt.Reset()
+	}
+}
diff --git a/vendor/github.com/pborman/getopt/v2/signed.go b/vendor/github.com/pborman/getopt/v2/signed.go
new file mode 100644
index 0000000..dc371a7
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/signed.go
@@ -0,0 +1,110 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import (
+	"fmt"
+	"strconv"
+	"sync"
+)
+
+type signed int64
+
+type SignedLimit struct {
+	Base int   // Base for conversion as per strconv.ParseInt
+	Bits int   // Number of bits as per strconv.ParseInt
+	Min  int64 // Minimum allowed value if both Min and Max are not 0
+	Max  int64 // Maximum allowed value if both Min and Max are not 0
+}
+
+var (
+	signedLimitsMu sync.Mutex
+	signedLimits   = make(map[*signed]*SignedLimit)
+)
+
+func (n *signed) Set(value string, opt Option) error {
+	signedLimitsMu.Lock()
+	l := signedLimits[n]
+	signedLimitsMu.Unlock()
+	if l == nil {
+		return fmt.Errorf("no limits defined for %s", opt.Name())
+	}
+	v, err := strconv.ParseInt(value, l.Base, l.Bits)
+	if err != nil {
+		if e, ok := err.(*strconv.NumError); ok {
+			switch e.Err {
+			case strconv.ErrRange:
+				err = fmt.Errorf("value out of range: %s", value)
+			case strconv.ErrSyntax:
+				err = fmt.Errorf("not a valid number: %s", value)
+			}
+		}
+		return err
+	}
+	if l.Min != 0 || l.Max != 0 {
+		if v < l.Min {
+			return fmt.Errorf("value out of range (<%v): %s", l.Min, value)
+		}
+		if v > l.Max {
+			return fmt.Errorf("value out of range (>%v): %s", l.Max, value)
+		}
+	}
+	*n = signed(v)
+	return nil
+}
+
+func (n *signed) String() string {
+	signedLimitsMu.Lock()
+	l := signedLimits[n]
+	signedLimitsMu.Unlock()
+	if l != nil && l.Base != 0 {
+		return strconv.FormatInt(int64(*n), l.Base)
+	}
+	return strconv.FormatInt(int64(*n), 10)
+}
+
+// Signed creates an option that is stored in an int64 and is constrained
+// by the limits pointed to by l.  The Max and Min values are only used if
+// at least one of the values are not 0.   If Base is 0, the base is implied by
+// the string's prefix: base 16 for "0x", base 8 for "0", and base 10 otherwise.
+func Signed(name rune, value int64, l *SignedLimit, helpvalue ...string) *int64 {
+	CommandLine.signedOption(&value, "", name, l, helpvalue...)
+	return &value
+}
+
+func (s *Set) Signed(name rune, value int64, l *SignedLimit, helpvalue ...string) *int64 {
+	s.signedOption(&value, "", name, l, helpvalue...)
+	return &value
+}
+
+func SignedLong(name string, short rune, value int64, l *SignedLimit, helpvalue ...string) *int64 {
+	CommandLine.signedOption(&value, name, short, l, helpvalue...)
+	return &value
+}
+
+func (s *Set) SignedLong(name string, short rune, value int64, l *SignedLimit, helpvalue ...string) *int64 {
+	s.signedOption(&value, name, short, l, helpvalue...)
+	return &value
+}
+
+func (s *Set) signedOption(p *int64, name string, short rune, l *SignedLimit, helpvalue ...string) {
+	opt := s.FlagLong((*signed)(p), name, short, helpvalue...)
+	if l.Base > 36 || l.Base == 1 || l.Base < 0 {
+		fmt.Fprintf(stderr, "invalid base for %s: %d\n", opt.Name(), l.Base)
+		exit(1)
+	}
+	if l.Bits < 0 || l.Bits > 64 {
+		fmt.Fprintf(stderr, "invalid bit size for %s: %d\n", opt.Name(), l.Bits)
+		exit(1)
+	}
+	if l.Min > l.Max {
+		fmt.Fprintf(stderr, "min greater than max for %s\n", opt.Name())
+		exit(1)
+	}
+	lim := *l
+	signedLimitsMu.Lock()
+	signedLimits[(*signed)(p)] = &lim
+	signedLimitsMu.Unlock()
+}
diff --git a/vendor/github.com/pborman/getopt/v2/string.go b/vendor/github.com/pborman/getopt/v2/string.go
new file mode 100644
index 0000000..cab5733
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/string.go
@@ -0,0 +1,27 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+// String returns a value option that stores is value as a string.  The
+// initial value of the string is passed in value.
+func String(name rune, value string, helpvalue ...string) *string {
+	CommandLine.Flag(&value, name, helpvalue...)
+	return &value
+}
+
+func (s *Set) String(name rune, value string, helpvalue ...string) *string {
+	s.Flag(&value, name, helpvalue...)
+	return &value
+}
+
+func StringLong(name string, short rune, value string, helpvalue ...string) *string {
+	CommandLine.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
+
+func (s *Set) StringLong(name string, short rune, value string, helpvalue ...string) *string {
+	s.FlagLong(&value, name, short, helpvalue...)
+	return &value
+}
diff --git a/vendor/github.com/pborman/getopt/v2/unsigned.go b/vendor/github.com/pborman/getopt/v2/unsigned.go
new file mode 100644
index 0000000..5594660
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/unsigned.go
@@ -0,0 +1,111 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import (
+	"fmt"
+	"strconv"
+	"sync"
+)
+
+type unsigned uint64
+
+type UnsignedLimit struct {
+	Base int    // Base for conversion as per strconv.ParseInt
+	Bits int    // Number of bits as per strconv.ParseInt
+	Min  uint64 // Minimum allowed value if both Min and Max are not 0
+	Max  uint64 // Maximum allowed value if both Min and Max are not 0
+}
+
+var (
+	unsignedLimitsMu sync.Mutex
+	unsignedLimits   = make(map[*unsigned]*UnsignedLimit)
+)
+
+func (n *unsigned) Set(value string, opt Option) error {
+	unsignedLimitsMu.Lock()
+	l := unsignedLimits[n]
+	unsignedLimitsMu.Unlock()
+	if l == nil {
+		return fmt.Errorf("no limits defined for %s", opt.Name())
+	}
+	v, err := strconv.ParseUint(value, l.Base, l.Bits)
+	if err != nil {
+		if e, ok := err.(*strconv.NumError); ok {
+			switch e.Err {
+			case strconv.ErrRange:
+				err = fmt.Errorf("value out of range: %s", value)
+			case strconv.ErrSyntax:
+				err = fmt.Errorf("not a valid number: %s", value)
+			}
+		}
+		return err
+	}
+	if l.Min != 0 || l.Max != 0 {
+		if v < l.Min {
+			return fmt.Errorf("value out of range (<%v): %s", l.Min, value)
+		}
+		if v > l.Max {
+			return fmt.Errorf("value out of range (>%v): %s", l.Max, value)
+		}
+	}
+	*n = unsigned(v)
+	return nil
+}
+
+func (n *unsigned) String() string {
+	unsignedLimitsMu.Lock()
+	l := unsignedLimits[n]
+	unsignedLimitsMu.Unlock()
+	if l != nil && l.Base != 0 {
+		return strconv.FormatUint(uint64(*n), l.Base)
+	}
+	return strconv.FormatUint(uint64(*n), 10)
+}
+
+// Unsigned creates an option that is stored in a uint64 and is
+// constrained by the limits pointed to by l.  The Max and Min values are only
+// used if at least one of the values are not 0.   If Base is 0, the base is
+// implied by the string's prefix: base 16 for "0x", base 8 for "0", and base
+// 10 otherwise.
+func Unsigned(name rune, value uint64, l *UnsignedLimit, helpvalue ...string) *uint64 {
+	CommandLine.unsignedOption(&value, "", name, l, helpvalue...)
+	return &value
+}
+
+func (s *Set) Unsigned(name rune, value uint64, l *UnsignedLimit, helpvalue ...string) *uint64 {
+	s.unsignedOption(&value, "", name, l, helpvalue...)
+	return &value
+}
+
+func UnsignedLong(name string, short rune, value uint64, l *UnsignedLimit, helpvalue ...string) *uint64 {
+	CommandLine.unsignedOption(&value, name, short, l, helpvalue...)
+	return &value
+}
+
+func (s *Set) UnsignedLong(name string, short rune, value uint64, l *UnsignedLimit, helpvalue ...string) *uint64 {
+	s.unsignedOption(&value, name, short, l, helpvalue...)
+	return &value
+}
+
+func (s *Set) unsignedOption(p *uint64, name string, short rune, l *UnsignedLimit, helpvalue ...string) {
+	opt := s.FlagLong((*unsigned)(p), name, short, helpvalue...)
+	if l.Base > 36 || l.Base == 1 || l.Base < 0 {
+		fmt.Fprintf(stderr, "invalid base for %s: %d\n", opt.Name(), l.Base)
+		exit(1)
+	}
+	if l.Bits < 0 || l.Bits > 64 {
+		fmt.Fprintf(stderr, "invalid bit size for %s: %d\n", opt.Name(), l.Bits)
+		exit(1)
+	}
+	if l.Min > l.Max {
+		fmt.Fprintf(stderr, "min greater than max for %s\n", opt.Name())
+		exit(1)
+	}
+	lim := *l
+	unsignedLimitsMu.Lock()
+	unsignedLimits[(*unsigned)(p)] = &lim
+	unsignedLimitsMu.Unlock()
+}
diff --git a/vendor/github.com/pborman/getopt/v2/var.go b/vendor/github.com/pborman/getopt/v2/var.go
new file mode 100644
index 0000000..0aaa79c
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/v2/var.go
@@ -0,0 +1,100 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+)
+
+// Value is the interface to the dynamic value stored in a flag.  Flags of type
+// Value are declared using the Flag and FlagLong functions.
+type Value interface {
+	// Set converts value into the appropriate type and assigns it to the
+	// receiver value.  Option details are provided via opt (such as the
+	// flags name).
+	//
+	// Set is used to reset the value of an option to its default value
+	// (which is stored in string form internally).
+	Set(value string, opt Option) error
+
+	// String returns the value of the flag as a string.
+	String() string
+}
+
+var thisPackage string
+
+// init initializes thisPackage to our full package with the trailing .
+// included.
+func init() {
+        pc, _, _, ok := runtime.Caller(0)
+        if !ok {
+                return
+        }
+        f := runtime.FuncForPC(pc)
+        if f == nil {
+                return
+        }
+        thisPackage = f.Name()
+        x := strings.LastIndex(thisPackage, "/")
+        if x < 0 {
+                return
+        }
+        y := strings.Index(thisPackage[x:], ".")
+        if y < 0 {
+                return
+        }
+        // thisPackage includes the trailing . after the package name.
+        thisPackage = thisPackage[:x+y+1]
+}
+
+// calledFrom returns a string containing the file and linenumber of the first
+// stack frame above us that is not part of this package and is not a test.
+// This is used to determine where a flag was initialized.
+func calledFrom() string {
+	for i := 2; ; i++ {
+		pc, file, line, ok := runtime.Caller(i)
+		if !ok {
+			return ""
+		}
+		if !strings.HasSuffix(file, "_test.go") {
+			f := runtime.FuncForPC(pc)
+			if f != nil && strings.HasPrefix(f.Name(), thisPackage) {
+				continue
+			}
+		}
+		return fmt.Sprintf("%s:%d", file, line)
+	}
+}
+
+func (s *Set) addFlag(p Value, name string, short rune, helpvalue ...string) Option {
+	opt := &option{
+		short:  short,
+		long:   name,
+		value:  p,
+		defval: p.String(),
+	}
+
+	switch len(helpvalue) {
+	case 2:
+		opt.name = helpvalue[1]
+		fallthrough
+	case 1:
+		opt.help = helpvalue[0]
+	case 0:
+	default:
+		panic("Too many strings for String helpvalue")
+	}
+	if where := calledFrom(); where != "" {
+		opt.where = where
+	}
+	if opt.short == 0 && opt.long == "" {
+		fmt.Fprintf(stderr, opt.where+": no short or long option given")
+		exit(1)
+	}
+	s.AddOption(opt)
+	return opt
+}
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 13ba6d0..c32c2c8 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -8,6 +8,12 @@
 			"revision": "6093f50721ed2204a87a81109ca5a466a5bec6c1",
 			"revisionTime": "2019-01-24T09:32:44Z"
 		},
+		{
+			"checksumSHA1": "ga3iSYiBaWixOMzuEdqiWSKboIY=",
+			"path": "github.com/pborman/getopt/v2",
+			"revision": "7402d34a12a86832e3faea504d412c319b3bf1a1",
+			"revisionTime": "2019-01-30T02:22:37Z"
+		},
 		{
 			"checksumSHA1": "MJT8XvrS9QMyfN41clFA7Dgp5Qk=",
 			"path": "salsa.debian.org/mdosch-guest/gopkg/jid",