func NewFloats64(into *[]float64, v []float64) *Floats64Value {
	*into = v
	return (*Floats64Value)(into)
}
NewFloats64 creates a new multi-int value
package values
import (
	"flag"
	"fmt"
	"strconv"
)
type BoolValued interface {
	flag.Value
	IsBoolFlag() bool
}
type MultiValued interface {
	flag.Value
	Clear()
}
type DefaultValued interface {
	IsDefault() bool
}
type BoolValue bool
var (
	_ flag.Value    = NewBool(new(bool), false)
	_ BoolValued    = NewBool(new(bool), false)
	_ DefaultValued = NewBool(new(bool), false)
)
func NewBool(into *bool, v bool) *BoolValue {
	*into = v
	return (*BoolValue)(into)
}
func (bo *BoolValue) Set(s string) error {
	b, err := strconv.ParseBool(s)
	if err != nil {
		return err
	}
	*bo = BoolValue(b)
	return nil
}
func (bo *BoolValue) IsBoolFlag() bool {
	return true
}
func (bo *BoolValue) String() string {
	return fmt.Sprintf("%v", *bo)
}
func (bo *BoolValue) IsDefault() bool {
	return !bool(*bo)
}
type StringValue string
var (
	_ flag.Value    = NewString(new(string), "")
	_ DefaultValued = NewString(new(string), "")
)
func NewString(into *string, v string) *StringValue {
	*into = v
	return (*StringValue)(into)
}
func (sa *StringValue) Set(s string) error {
	*sa = StringValue(s)
	return nil
}
func (sa *StringValue) String() string {
	return fmt.Sprintf("%#v", *sa)
}
func (sa *StringValue) IsDefault() bool {
	return string(*sa) == ""
}
type IntValue int
var (
	_ flag.Value = NewInt(new(int), 0)
)
func NewInt(into *int, v int) *IntValue {
	*into = v
	return (*IntValue)(into)
}
func (ia *IntValue) Set(s string) error {
	i, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		return err
	}
	*ia = IntValue(int(i))
	return nil
}
func (ia *IntValue) String() string {
	return fmt.Sprintf("%v", *ia)
}
type Float64Value float64
var (
	_ flag.Value = NewFloat64(new(float64), 0)
)
func NewFloat64(into *float64, v float64) *Float64Value {
	*into = v
	return (*Float64Value)(into)
}
func (ia *Float64Value) Set(s string) error {
	i, err := strconv.ParseFloat(s, 64)
	if err != nil {
		return err
	}
	*ia = Float64Value(i)
	return nil
}
func (ia *Float64Value) String() string {
	return fmt.Sprintf("%v", *ia)
}
type StringsValue []string
var (
	_ flag.Value    = NewStrings(new([]string), nil)
	_ MultiValued   = NewStrings(new([]string), nil)
	_ DefaultValued = NewStrings(new([]string), nil)
)
func NewStrings(into *[]string, v []string) *StringsValue {
	*into = v
	return (*StringsValue)(into)
}
func (sa *StringsValue) Set(s string) error {
	*sa = append(*sa, s)
	return nil
}
func (sa *StringsValue) String() string {
	res := "["
	for idx, s := range *sa {
		if idx > 0 {
			res += ", "
		}
		res += fmt.Sprintf("%#v", s)
	}
	return res + "]"
}
func (sa *StringsValue) Clear() {
	*sa = nil
}
func (sa *StringsValue) IsDefault() bool {
	return len(*sa) == 0
}
type IntsValue []int
var (
	_ flag.Value    = NewInts(new([]int), nil)
	_ MultiValued   = NewInts(new([]int), nil)
	_ DefaultValued = NewInts(new([]int), nil)
)
func NewInts(into *[]int, v []int) *IntsValue {
	*into = v
	return (*IntsValue)(into)
}
func (ia *IntsValue) Set(s string) error {
	i, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		return err
	}
	*ia = append(*ia, int(i))
	return nil
}
func (ia *IntsValue) String() string {
	res := "["
	for idx, s := range *ia {
		if idx > 0 {
			res += ", "
		}
		res += fmt.Sprintf("%v", s)
	}
	return res + "]"
}
func (ia *IntsValue) Clear() {
	*ia = nil
}
func (ia *IntsValue) IsDefault() bool {
	return len(*ia) == 0
}
type Floats64Value []float64
var (
	_ flag.Value    = NewFloats64(new([]float64), nil)
	_ MultiValued   = NewFloats64(new([]float64), nil)
	_ DefaultValued = NewFloats64(new([]float64), nil)
)