diff --git a/README.md b/README.md
index f936162..93d5c05 100644
--- a/README.md
+++ b/README.md
@@ -23,14 +23,13 @@ And you can use your favorite flag or cli library!
 
 ## Supported libraries and features:
 
-|     |     | Hidden | Deprecated | Short | Env |
-| --- | --- |:------:|:----------:|:-----:|:---:|
-| <ul><li>[x] [flag]</li><ul> | [example](./examples/flag/main.go) | `-` | `-` | `-` | `-` |
-| <ul><li>[x] [kingpin]</li></ul> | [example](./examples/kingpin/main.go) | <ul><li>[x] </li></ul> | <ul><li>[ ] </li></ul> | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> |
-| <ul><li>[x] [spf13/pflag]</li></ul> | [example](./examples/pflag/main.go) | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> | `-` |
-| <ul><li>[x] [spf13/cobra]</li></ul> | [example](./examples/cobra/main.go) | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> | `-` |
-| <ul><li>[ ] [spf13/viper]</li><ul> |   | <ul><li>[ ] </li></ul> | <ul><li>[ ] </li></ul> | <ul><li>[ ] </li></ul> | <ul><li>[ ] </li></ul> |
-| <ul><li>[x] [urfave/cli]</li></ul> | [example](./examples/urfave_cli/main.go) | <ul><li>[x] </li></ul> | `-` | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> |
+|     |     | Hidden | Deprecated | Short | Env | Required |
+| --- | --- |:------:|:----------:|:-----:|:---:|:--------:|
+| <ul><li>[x] [flag]</li><ul> | [example](./examples/flag/main.go) | `-` | `-` | `-` | `-` | `-` |
+| <ul><li>[x] [kingpin]</li></ul> | [example](./examples/kingpin/main.go) | <ul><li>[x] </li></ul> | <ul><li>[ ] </li></ul> | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> |
+| <ul><li>[x] [spf13/pflag]</li></ul> | [example](./examples/pflag/main.go) | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> | `-` | `-` |
+| <ul><li>[x] [spf13/cobra]</li></ul> | [example](./examples/cobra/main.go) | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> | `-` | `-` |
+| <ul><li>[x] [urfave/cli]</li></ul> | [example](./examples/urfave_cli/main.go) | <ul><li>[x] </li></ul> | `-` | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> | <ul><li>[x] </li></ul> |
 
 - [x] - feature is supported and implemented
 
@@ -50,7 +49,7 @@ And you can use your favorite flag or cli library!
  - [x] Set usage
  - [x] Long and short forms
  - [x] Skip field
- - [ ] Required
+ - [x] Required
  - [ ] Placeholders (by `name`)
  - [x] Deprecated and hidden options
  - [ ] Multiple ENV names
diff --git a/flag.go b/flag.go
index 4ceaaa1..cdd2c90 100644
--- a/flag.go
+++ b/flag.go
@@ -11,4 +11,5 @@ type Flag struct {
 	DefValue   string // default value (as text); for usage message
 	Hidden     bool
 	Deprecated bool
+	Required   bool
 }
diff --git a/gen/gcli/gcli.go b/gen/gcli/gcli.go
index de2472e..f6c2391 100644
--- a/gen/gcli/gcli.go
+++ b/gen/gcli/gcli.go
@@ -15,12 +15,13 @@ func GenerateTo(src []*sflags.Flag, dst *[]cli.Flag) {
 			aliases = append(aliases, srcFlag.Short)
 		}
 		*dst = append(*dst, &cli.GenericFlag{
-			Name:    name,
-			EnvVars: []string{srcFlag.EnvName},
-			Aliases: aliases,
-			Hidden:  srcFlag.Hidden,
-			Usage:   srcFlag.Usage,
-			Value:   srcFlag.Value,
+			Name:     name,
+			EnvVars:  []string{srcFlag.EnvName},
+			Aliases:  aliases,
+			Hidden:   srcFlag.Hidden,
+			Usage:    srcFlag.Usage,
+			Value:    srcFlag.Value,
+			Required: srcFlag.Required,
 		})
 	}
 }
diff --git a/gen/gcli/gcli_test.go b/gen/gcli/gcli_test.go
index 0c52346..940704c 100644
--- a/gen/gcli/gcli_test.go
+++ b/gen/gcli/gcli_test.go
@@ -2,7 +2,9 @@ package gcli
 
 import (
 	"errors"
+	"fmt"
 	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -14,6 +16,7 @@ import (
 type cfg1 struct {
 	StringValue1 string
 	StringValue2 string `flag:"string-value-two s"`
+	StringValue3 string `flag:",required"`
 
 	CounterValue1 sflags.Counter
 
@@ -35,6 +38,7 @@ func TestParse(t *testing.T) {
 			cfg: &cfg1{
 				StringValue1: "string_value1_value",
 				StringValue2: "string_value2_value",
+				StringValue3: "string_value3_value",
 
 				CounterValue1: 1,
 
@@ -43,6 +47,7 @@ func TestParse(t *testing.T) {
 			expCfg: &cfg1{
 				StringValue1: "string_value1_value2",
 				StringValue2: "string_value2_value2",
+				StringValue3: "string_value3_value2",
 
 				CounterValue1: 3,
 
@@ -52,6 +57,7 @@ func TestParse(t *testing.T) {
 			args: []string{
 				"--string-value1", "string_value1_value2",
 				"--string-value-two", "string_value2_value2",
+				"--string-value3", "string_value3_value2",
 				"--counter-value1", "--counter-value1",
 				"--string-slice-value1", "one2",
 				"--string-slice-value1", "two2",
@@ -68,7 +74,8 @@ func TestParse(t *testing.T) {
 				StringValue1: "string_value1_value",
 				StringValue2: "",
 			},
-			args: []string{},
+			args:    []string{},
+			expErr2: fmt.Errorf("required flag \"string-value3\" not set"),
 		},
 		{
 			name: "Test cfg1 short option",
@@ -77,8 +84,10 @@ func TestParse(t *testing.T) {
 			},
 			expCfg: &cfg1{
 				StringValue2: "string_value2_value2",
+				StringValue3: "string_value3_value2",
 			},
 			args: []string{
+				"--string-value3", "string_value3_value2",
 				"-s=string_value2_value2",
 			},
 		},
@@ -88,12 +97,14 @@ func TestParse(t *testing.T) {
 			expCfg: &cfg1{
 				StringValue1: "string_value1_value2",
 				StringValue2: "string_value2_value2",
+				StringValue3: "string_value3_value2",
 
 				CounterValue1: 3,
 			},
 			args: []string{
 				"--string-value1", "string_value1_value2",
 				"--string-value-two", "string_value2_value2",
+				"--string-value3", "string_value3_value2",
 				"--counter-value1=2", "--counter-value1",
 			},
 		},
@@ -142,7 +153,7 @@ func TestParse(t *testing.T) {
 			err = cliApp.Run(args)
 			if test.expErr2 != nil {
 				require.Error(t, err)
-				require.Equal(t, test.expErr2, err)
+				require.Equal(t, test.expErr2.Error(), strings.ToLower(err.Error()))
 			} else {
 				require.NoError(t, err)
 			}
diff --git a/gen/gcli/gcliv3.go b/gen/gcli/gcliv3.go
index 7c6fa9f..d6f71f8 100644
--- a/gen/gcli/gcliv3.go
+++ b/gen/gcli/gcliv3.go
@@ -48,6 +48,7 @@ func GenerateToV3(src []*sflags.Flag, dst *[]cli.Flag) {
 			Value: &value{
 				v: srcFlag.Value,
 			},
+			Required: srcFlag.Required,
 		})
 	}
 }
diff --git a/gen/gcli/gcliv3_test.go b/gen/gcli/gcliv3_test.go
index 7088f25..284bf50 100644
--- a/gen/gcli/gcliv3_test.go
+++ b/gen/gcli/gcliv3_test.go
@@ -3,7 +3,9 @@ package gcli
 import (
 	"context"
 	"errors"
+	"fmt"
 	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -15,6 +17,7 @@ import (
 type cfg2 struct {
 	StringValue1 string
 	StringValue2 string `flag:"string-value-two s"`
+	StringValue3 string `flag:",required"`
 
 	CounterValue1 sflags.Counter
 
@@ -36,6 +39,7 @@ func TestParseV3(t *testing.T) {
 			cfg: &cfg2{
 				StringValue1: "string_value1_value",
 				StringValue2: "string_value2_value",
+				StringValue3: "string_value3_value",
 
 				CounterValue1: 1,
 
@@ -44,6 +48,7 @@ func TestParseV3(t *testing.T) {
 			expCfg: &cfg2{
 				StringValue1: "string_value1_value2",
 				StringValue2: "string_value2_value2",
+				StringValue3: "string_value3_value2",
 
 				CounterValue1: 3,
 
@@ -53,6 +58,7 @@ func TestParseV3(t *testing.T) {
 			args: []string{
 				"--string-value1", "string_value1_value2",
 				"--string-value-two", "string_value2_value2",
+				"--string-value3", "string_value3_value2",
 				"--counter-value1", "--counter-value1",
 				"--string-slice-value1", "one2",
 				"--string-slice-value1", "two2",
@@ -69,7 +75,8 @@ func TestParseV3(t *testing.T) {
 				StringValue1: "string_value1_value",
 				StringValue2: "",
 			},
-			args: []string{},
+			args:    []string{},
+			expErr2: fmt.Errorf("required flag \"string-value3\" not set"),
 		},
 		{
 			name: "Test cfg2 short option",
@@ -78,8 +85,10 @@ func TestParseV3(t *testing.T) {
 			},
 			expCfg: &cfg2{
 				StringValue2: "string_value2_value2",
+				StringValue3: "string_value3_value2",
 			},
 			args: []string{
+				"--string-value3", "string_value3_value2",
 				"-s=string_value2_value2",
 			},
 		},
@@ -89,12 +98,14 @@ func TestParseV3(t *testing.T) {
 			expCfg: &cfg2{
 				StringValue1: "string_value1_value2",
 				StringValue2: "string_value2_value2",
+				StringValue3: "string_value3_value2",
 
 				CounterValue1: 3,
 			},
 			args: []string{
 				"--string-value1", "string_value1_value2",
 				"--string-value-two", "string_value2_value2",
+				"--string-value3", "string_value3_value2",
 				"--counter-value1=2", "--counter-value1",
 			},
 		},
@@ -143,7 +154,7 @@ func TestParseV3(t *testing.T) {
 			err = cmd.Run(context.Background(), args)
 			if test.expErr2 != nil {
 				require.Error(t, err)
-				require.Equal(t, test.expErr2, err)
+				require.Equal(t, test.expErr2.Error(), strings.ToLower(err.Error()))
 			} else {
 				require.NoError(t, err)
 			}
diff --git a/gen/gkingpin/gkingpin.go b/gen/gkingpin/gkingpin.go
index 82841dd..7c25547 100644
--- a/gen/gkingpin/gkingpin.go
+++ b/gen/gkingpin/gkingpin.go
@@ -23,6 +23,9 @@ func GenerateTo(src []*sflags.Flag, dst flagger) {
 		if srcFlag.Hidden {
 			flag.Hidden()
 		}
+		if srcFlag.Required {
+			flag.Required()
+		}
 		if srcFlag.Short != "" {
 			r, _ := utf8.DecodeRuneInString(srcFlag.Short)
 			if r != utf8.RuneError {
diff --git a/gen/gkingpin/gkingpin_test.go b/gen/gkingpin/gkingpin_test.go
index 4dab690..700189d 100644
--- a/gen/gkingpin/gkingpin_test.go
+++ b/gen/gkingpin/gkingpin_test.go
@@ -13,6 +13,7 @@ import (
 type cfg1 struct {
 	StringValue1 string
 	StringValue2 string `flag:"string-value-two s"`
+	StringValue3 string `flag:",required"`
 
 	CounterValue1 sflags.Counter
 
@@ -34,6 +35,7 @@ func TestParse(t *testing.T) {
 			cfg: &cfg1{
 				StringValue1: "string_value1_value",
 				StringValue2: "string_value2_value",
+				StringValue3: "string_value3_value",
 
 				CounterValue1: 1,
 
@@ -42,6 +44,7 @@ func TestParse(t *testing.T) {
 			expCfg: &cfg1{
 				StringValue1: "string_value1_value2",
 				StringValue2: "string_value2_value2",
+				StringValue3: "string_value3_value2",
 
 				CounterValue1: 3,
 
@@ -51,6 +54,7 @@ func TestParse(t *testing.T) {
 			args: []string{
 				"--string-value1", "string_value1_value2",
 				"--string-value-two", "string_value2_value2",
+				"--string-value3", "string_value3_value2",
 				"--counter-value1", "--counter-value1",
 				"--string-slice-value1", "one2",
 				"--string-slice-value1", "two2",
@@ -67,7 +71,8 @@ func TestParse(t *testing.T) {
 				StringValue1: "string_value1_value",
 				StringValue2: "",
 			},
-			args: []string{},
+			args:    []string{},
+			expErr2: errors.New("required flag(s) '--string-value3' not provided"),
 		},
 		{
 			name: "Test cfg1 short option",
@@ -76,8 +81,10 @@ func TestParse(t *testing.T) {
 			},
 			expCfg: &cfg1{
 				StringValue2: "string_value2_value2",
+				StringValue3: "string_value3_value",
 			},
 			args: []string{
+				"--string-value3", "string_value3_value",
 				"-s", "string_value2_value2",
 			},
 		},
@@ -87,12 +94,14 @@ func TestParse(t *testing.T) {
 			expCfg: &cfg1{
 				StringValue1: "string_value1_value2",
 				StringValue2: "string_value2_value2",
+				StringValue3: "string_value3_value2",
 
 				CounterValue1: 1,
 			},
 			args: []string{
 				"--string-value1", "string_value1_value2",
 				"--string-value-two", "string_value2_value2",
+				"--string-value3", "string_value3_value2",
 				// kingpin can't pass value for boolean arguments.
 				//"--counter-value1", "2",
 				"--counter-value1",
diff --git a/parser.go b/parser.go
index ff2a472..8199433 100644
--- a/parser.go
+++ b/parser.go
@@ -114,7 +114,7 @@ func parseFlagTag(field reflect.StructField, opt opts) *Flag {
 		}
 		flag.Hidden = hasOption(flagTags[1:], "hidden")
 		flag.Deprecated = hasOption(flagTags[1:], "deprecated")
-
+		flag.Required = hasOption(flagTags[1:], "required")
 	}
 
 	if opt.prefix != "" && !ignoreFlagPrefix {
diff --git a/parser_test.go b/parser_test.go
index a7cc231..da39eac 100644
--- a/parser_test.go
+++ b/parser_test.go
@@ -27,6 +27,7 @@ func TestParseStruct(t *testing.T) {
 		Name4 *string
 		Name5 string `flag:"-"`
 		name6 string
+		Name7 int `flag:",required"`
 
 		Addr *net.TCPAddr
 
@@ -147,6 +148,13 @@ func TestParseStruct(t *testing.T) {
 					DefValue: "name_value4",
 					Value:    newStringValue(simpleCfg.Name4),
 				},
+				{
+					Name:     "name7",
+					EnvName:  "NAME7",
+					Required: true,
+					DefValue: "0",
+					Value:    newIntValue(&simpleCfg.Name7),
+				},
 				{
 					Name:     "addr",
 					EnvName:  "ADDR",
@@ -194,6 +202,13 @@ func TestParseStruct(t *testing.T) {
 					DefValue: "name_value4",
 					Value:    newStringValue(simpleCfg.Name4),
 				},
+				{
+					Name:     "name7",
+					EnvName:  "PP|NAME7",
+					Required: true,
+					DefValue: "0",
+					Value:    newIntValue(&simpleCfg.Name7),
+				},
 				{
 					Name:     "addr",
 					EnvName:  "PP|ADDR",
diff --git a/values_generated_test.go b/values_generated_test.go
index 282d61b..02ce66b 100644
--- a/values_generated_test.go
+++ b/values_generated_test.go
@@ -167,13 +167,13 @@ func TestStringStringMapValue(t *testing.T) {
 		v := newStringStringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("dzMfxval1")
+		err = v.Set("PjnxHval1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("XcrRz:val1")
+		err = v.Set("JGJtB:val1")
 		assert.Nil(t, err)
-		err = v.Set("WjIXlval2")
+		err = v.Set("jZFHkval2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("DqGev:val2")
+		err = v.Set("iHPlL:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]string", v.Type())
@@ -185,9 +185,9 @@ func TestStringStringMapValue(t *testing.T) {
 		v := newStringStringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("dXmJx")
+		err = v.Set("QhsBt")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("jQufn:")
+		err = v.Set("Pviem:")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]string", v.Type())
@@ -202,17 +202,17 @@ func TestIntStringMapValue(t *testing.T) {
 		v := newIntStringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3val1")
+		err = v.Set("6val1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val1")
 		assert.NotNil(t, err)
-		err = v.Set("7:val1")
+		err = v.Set("6:val1")
 		assert.Nil(t, err)
-		err = v.Set("6val2")
+		err = v.Set("3val2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val2")
 		assert.NotNil(t, err)
-		err = v.Set("2:val2")
+		err = v.Set("3:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]string", v.Type())
@@ -224,11 +224,11 @@ func TestIntStringMapValue(t *testing.T) {
 		v := newIntStringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1")
+		err = v.Set("3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":")
 		assert.NotNil(t, err)
-		err = v.Set("7:")
+		err = v.Set("2:")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]string", v.Type())
@@ -243,17 +243,17 @@ func TestInt8StringMapValue(t *testing.T) {
 		v := newInt8StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1val1")
+		err = v.Set("4val1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val1")
 		assert.NotNil(t, err)
-		err = v.Set("4:val1")
+		err = v.Set("1:val1")
 		assert.Nil(t, err)
-		err = v.Set("1val2")
+		err = v.Set("6val2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val2")
 		assert.NotNil(t, err)
-		err = v.Set("7:val2")
+		err = v.Set("3:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]string", v.Type())
@@ -265,11 +265,11 @@ func TestInt8StringMapValue(t *testing.T) {
 		v := newInt8StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1")
+		err = v.Set("5")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":")
 		assert.NotNil(t, err)
-		err = v.Set("4:")
+		err = v.Set("5:")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]string", v.Type())
@@ -288,13 +288,13 @@ func TestInt16StringMapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val1")
 		assert.NotNil(t, err)
-		err = v.Set("7:val1")
+		err = v.Set("6:val1")
 		assert.Nil(t, err)
-		err = v.Set("1val2")
+		err = v.Set("7val2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val2")
 		assert.NotNil(t, err)
-		err = v.Set("2:val2")
+		err = v.Set("7:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]string", v.Type())
@@ -306,7 +306,7 @@ func TestInt16StringMapValue(t *testing.T) {
 		v := newInt16StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0")
+		err = v.Set("6")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":")
 		assert.NotNil(t, err)
@@ -325,17 +325,17 @@ func TestInt32StringMapValue(t *testing.T) {
 		v := newInt32StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3val1")
+		err = v.Set("4val1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val1")
 		assert.NotNil(t, err)
-		err = v.Set("4:val1")
+		err = v.Set("1:val1")
 		assert.Nil(t, err)
-		err = v.Set("2val2")
+		err = v.Set("1val2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val2")
 		assert.NotNil(t, err)
-		err = v.Set("4:val2")
+		err = v.Set("5:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]string", v.Type())
@@ -347,11 +347,11 @@ func TestInt32StringMapValue(t *testing.T) {
 		v := newInt32StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2")
+		err = v.Set("5")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":")
 		assert.NotNil(t, err)
-		err = v.Set("1:")
+		err = v.Set("2:")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]string", v.Type())
@@ -366,17 +366,17 @@ func TestInt64StringMapValue(t *testing.T) {
 		v := newInt64StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2val1")
+		err = v.Set("6val1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val1")
 		assert.NotNil(t, err)
 		err = v.Set("3:val1")
 		assert.Nil(t, err)
-		err = v.Set("0val2")
+		err = v.Set("7val2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val2")
 		assert.NotNil(t, err)
-		err = v.Set("2:val2")
+		err = v.Set("5:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]string", v.Type())
@@ -388,11 +388,11 @@ func TestInt64StringMapValue(t *testing.T) {
 		v := newInt64StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5")
+		err = v.Set("0")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":")
 		assert.NotNil(t, err)
-		err = v.Set("7:")
+		err = v.Set("0:")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]string", v.Type())
@@ -407,17 +407,17 @@ func TestUintStringMapValue(t *testing.T) {
 		v := newUintStringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7val1")
+		err = v.Set("6val1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val1")
 		assert.NotNil(t, err)
-		err = v.Set("7:val1")
+		err = v.Set("3:val1")
 		assert.Nil(t, err)
-		err = v.Set("4val2")
+		err = v.Set("7val2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val2")
 		assert.NotNil(t, err)
-		err = v.Set("3:val2")
+		err = v.Set("1:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]string", v.Type())
@@ -429,11 +429,11 @@ func TestUintStringMapValue(t *testing.T) {
 		v := newUintStringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2")
+		err = v.Set("3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":")
 		assert.NotNil(t, err)
-		err = v.Set("5:")
+		err = v.Set("7:")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]string", v.Type())
@@ -448,17 +448,17 @@ func TestUint8StringMapValue(t *testing.T) {
 		v := newUint8StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4val1")
+		err = v.Set("3val1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val1")
 		assert.NotNil(t, err)
-		err = v.Set("7:val1")
+		err = v.Set("1:val1")
 		assert.Nil(t, err)
-		err = v.Set("6val2")
+		err = v.Set("4val2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val2")
 		assert.NotNil(t, err)
-		err = v.Set("2:val2")
+		err = v.Set("1:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]string", v.Type())
@@ -470,11 +470,11 @@ func TestUint8StringMapValue(t *testing.T) {
 		v := newUint8StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4")
+		err = v.Set("3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":")
 		assert.NotNil(t, err)
-		err = v.Set("0:")
+		err = v.Set("4:")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]string", v.Type())
@@ -489,17 +489,17 @@ func TestUint16StringMapValue(t *testing.T) {
 		v := newUint16StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6val1")
+		err = v.Set("4val1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val1")
 		assert.NotNil(t, err)
 		err = v.Set("0:val1")
 		assert.Nil(t, err)
-		err = v.Set("5val2")
+		err = v.Set("0val2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val2")
 		assert.NotNil(t, err)
-		err = v.Set("0:val2")
+		err = v.Set("1:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]string", v.Type())
@@ -511,11 +511,11 @@ func TestUint16StringMapValue(t *testing.T) {
 		v := newUint16StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0")
+		err = v.Set("2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":")
 		assert.NotNil(t, err)
-		err = v.Set("2:")
+		err = v.Set("3:")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]string", v.Type())
@@ -534,13 +534,13 @@ func TestUint32StringMapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val1")
 		assert.NotNil(t, err)
-		err = v.Set("2:val1")
+		err = v.Set("0:val1")
 		assert.Nil(t, err)
-		err = v.Set("6val2")
+		err = v.Set("1val2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val2")
 		assert.NotNil(t, err)
-		err = v.Set("4:val2")
+		err = v.Set("5:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]string", v.Type())
@@ -552,11 +552,11 @@ func TestUint32StringMapValue(t *testing.T) {
 		v := newUint32StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3")
+		err = v.Set("1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":")
 		assert.NotNil(t, err)
-		err = v.Set("3:")
+		err = v.Set("0:")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]string", v.Type())
@@ -575,13 +575,13 @@ func TestUint64StringMapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val1")
 		assert.NotNil(t, err)
-		err = v.Set("1:val1")
+		err = v.Set("4:val1")
 		assert.Nil(t, err)
-		err = v.Set("0val2")
+		err = v.Set("1val2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":val2")
 		assert.NotNil(t, err)
-		err = v.Set("4:val2")
+		err = v.Set("6:val2")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]string", v.Type())
@@ -593,11 +593,11 @@ func TestUint64StringMapValue(t *testing.T) {
 		v := newUint64StringMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6")
+		err = v.Set("5")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":")
 		assert.NotNil(t, err)
-		err = v.Set("5:")
+		err = v.Set("2:")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]string", v.Type())
@@ -813,13 +813,13 @@ func TestStringBoolMapValue(t *testing.T) {
 		v := newStringBoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("kBIsStrue")
+		err = v.Set("ztFTqtrue")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("mcfFU:true")
+		err = v.Set("RjWBg:true")
 		assert.Nil(t, err)
-		err = v.Set("apWUZfalse")
+		err = v.Set("prfzMfalse")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("LwwHu:false")
+		err = v.Set("kIMOi:false")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]bool", v.Type())
@@ -831,9 +831,9 @@ func TestStringBoolMapValue(t *testing.T) {
 		v := newStringBoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("TJTRSunexpected")
+		err = v.Set("NBOqcunexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("BnMTA:unexpected")
+		err = v.Set("tnDZE:unexpected")
 		assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]bool", v.Type())
@@ -848,17 +848,17 @@ func TestIntBoolMapValue(t *testing.T) {
 		v := newIntBoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1true")
+		err = v.Set("7true")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":true")
 		assert.NotNil(t, err)
-		err = v.Set("0:true")
+		err = v.Set("1:true")
 		assert.Nil(t, err)
-		err = v.Set("4false")
+		err = v.Set("0false")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":false")
 		assert.NotNil(t, err)
-		err = v.Set("2:false")
+		err = v.Set("5:false")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]bool", v.Type())
@@ -870,11 +870,11 @@ func TestIntBoolMapValue(t *testing.T) {
 		v := newIntBoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0unexpected")
+		err = v.Set("4unexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":unexpected")
 		assert.NotNil(t, err)
-		err = v.Set("4:unexpected")
+		err = v.Set("3:unexpected")
 		assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]bool", v.Type())
@@ -889,17 +889,17 @@ func TestInt8BoolMapValue(t *testing.T) {
 		v := newInt8BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6true")
+		err = v.Set("7true")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":true")
 		assert.NotNil(t, err)
 		err = v.Set("6:true")
 		assert.Nil(t, err)
-		err = v.Set("6false")
+		err = v.Set("3false")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":false")
 		assert.NotNil(t, err)
-		err = v.Set("2:false")
+		err = v.Set("5:false")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]bool", v.Type())
@@ -911,11 +911,11 @@ func TestInt8BoolMapValue(t *testing.T) {
 		v := newInt8BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4unexpected")
+		err = v.Set("3unexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":unexpected")
 		assert.NotNil(t, err)
-		err = v.Set("4:unexpected")
+		err = v.Set("5:unexpected")
 		assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]bool", v.Type())
@@ -930,17 +930,17 @@ func TestInt16BoolMapValue(t *testing.T) {
 		v := newInt16BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1true")
+		err = v.Set("6true")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":true")
 		assert.NotNil(t, err)
-		err = v.Set("3:true")
+		err = v.Set("6:true")
 		assert.Nil(t, err)
-		err = v.Set("1false")
+		err = v.Set("2false")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":false")
 		assert.NotNil(t, err)
-		err = v.Set("0:false")
+		err = v.Set("7:false")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]bool", v.Type())
@@ -952,7 +952,7 @@ func TestInt16BoolMapValue(t *testing.T) {
 		v := newInt16BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7unexpected")
+		err = v.Set("2unexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":unexpected")
 		assert.NotNil(t, err)
@@ -971,17 +971,17 @@ func TestInt32BoolMapValue(t *testing.T) {
 		v := newInt32BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1true")
+		err = v.Set("5true")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":true")
 		assert.NotNil(t, err)
-		err = v.Set("1:true")
+		err = v.Set("0:true")
 		assert.Nil(t, err)
-		err = v.Set("1false")
+		err = v.Set("0false")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":false")
 		assert.NotNil(t, err)
-		err = v.Set("5:false")
+		err = v.Set("0:false")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]bool", v.Type())
@@ -993,11 +993,11 @@ func TestInt32BoolMapValue(t *testing.T) {
 		v := newInt32BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1unexpected")
+		err = v.Set("6unexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":unexpected")
 		assert.NotNil(t, err)
-		err = v.Set("5:unexpected")
+		err = v.Set("3:unexpected")
 		assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]bool", v.Type())
@@ -1012,17 +1012,17 @@ func TestInt64BoolMapValue(t *testing.T) {
 		v := newInt64BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7true")
+		err = v.Set("0true")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":true")
 		assert.NotNil(t, err)
-		err = v.Set("4:true")
+		err = v.Set("7:true")
 		assert.Nil(t, err)
-		err = v.Set("5false")
+		err = v.Set("2false")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":false")
 		assert.NotNil(t, err)
-		err = v.Set("4:false")
+		err = v.Set("3:false")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]bool", v.Type())
@@ -1034,11 +1034,11 @@ func TestInt64BoolMapValue(t *testing.T) {
 		v := newInt64BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4unexpected")
+		err = v.Set("6unexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":unexpected")
 		assert.NotNil(t, err)
-		err = v.Set("5:unexpected")
+		err = v.Set("7:unexpected")
 		assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]bool", v.Type())
@@ -1053,17 +1053,17 @@ func TestUintBoolMapValue(t *testing.T) {
 		v := newUintBoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2true")
+		err = v.Set("3true")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":true")
 		assert.NotNil(t, err)
 		err = v.Set("1:true")
 		assert.Nil(t, err)
-		err = v.Set("0false")
+		err = v.Set("3false")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":false")
 		assert.NotNil(t, err)
-		err = v.Set("1:false")
+		err = v.Set("0:false")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]bool", v.Type())
@@ -1075,11 +1075,11 @@ func TestUintBoolMapValue(t *testing.T) {
 		v := newUintBoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2unexpected")
+		err = v.Set("1unexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":unexpected")
 		assert.NotNil(t, err)
-		err = v.Set("7:unexpected")
+		err = v.Set("2:unexpected")
 		assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]bool", v.Type())
@@ -1094,17 +1094,17 @@ func TestUint8BoolMapValue(t *testing.T) {
 		v := newUint8BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6true")
+		err = v.Set("4true")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":true")
 		assert.NotNil(t, err)
-		err = v.Set("0:true")
+		err = v.Set("4:true")
 		assert.Nil(t, err)
 		err = v.Set("3false")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":false")
 		assert.NotNil(t, err)
-		err = v.Set("1:false")
+		err = v.Set("3:false")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]bool", v.Type())
@@ -1116,11 +1116,11 @@ func TestUint8BoolMapValue(t *testing.T) {
 		v := newUint8BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4unexpected")
+		err = v.Set("3unexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":unexpected")
 		assert.NotNil(t, err)
-		err = v.Set("1:unexpected")
+		err = v.Set("0:unexpected")
 		assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]bool", v.Type())
@@ -1135,17 +1135,17 @@ func TestUint16BoolMapValue(t *testing.T) {
 		v := newUint16BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3true")
+		err = v.Set("2true")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":true")
 		assert.NotNil(t, err)
-		err = v.Set("2:true")
+		err = v.Set("7:true")
 		assert.Nil(t, err)
-		err = v.Set("0false")
+		err = v.Set("6false")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":false")
 		assert.NotNil(t, err)
-		err = v.Set("6:false")
+		err = v.Set("4:false")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]bool", v.Type())
@@ -1157,11 +1157,11 @@ func TestUint16BoolMapValue(t *testing.T) {
 		v := newUint16BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1unexpected")
+		err = v.Set("7unexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":unexpected")
 		assert.NotNil(t, err)
-		err = v.Set("1:unexpected")
+		err = v.Set("2:unexpected")
 		assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]bool", v.Type())
@@ -1176,13 +1176,13 @@ func TestUint32BoolMapValue(t *testing.T) {
 		v := newUint32BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1true")
+		err = v.Set("6true")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":true")
 		assert.NotNil(t, err)
-		err = v.Set("0:true")
+		err = v.Set("3:true")
 		assert.Nil(t, err)
-		err = v.Set("6false")
+		err = v.Set("7false")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":false")
 		assert.NotNil(t, err)
@@ -1198,11 +1198,11 @@ func TestUint32BoolMapValue(t *testing.T) {
 		v := newUint32BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5unexpected")
+		err = v.Set("2unexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":unexpected")
 		assert.NotNil(t, err)
-		err = v.Set("5:unexpected")
+		err = v.Set("0:unexpected")
 		assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]bool", v.Type())
@@ -1217,17 +1217,17 @@ func TestUint64BoolMapValue(t *testing.T) {
 		v := newUint64BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3true")
+		err = v.Set("2true")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":true")
 		assert.NotNil(t, err)
-		err = v.Set("6:true")
+		err = v.Set("2:true")
 		assert.Nil(t, err)
-		err = v.Set("3false")
+		err = v.Set("0false")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":false")
 		assert.NotNil(t, err)
-		err = v.Set("0:false")
+		err = v.Set("1:false")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]bool", v.Type())
@@ -1239,11 +1239,11 @@ func TestUint64BoolMapValue(t *testing.T) {
 		v := newUint64BoolMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6unexpected")
+		err = v.Set("1unexpected")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":unexpected")
 		assert.NotNil(t, err)
-		err = v.Set("0:unexpected")
+		err = v.Set("5:unexpected")
 		assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]bool", v.Type())
@@ -1449,13 +1449,13 @@ func TestStringUintMapValue(t *testing.T) {
 		v := newStringUintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("ULDsu10")
+		err = v.Set("enuzv10")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("LRHqe:10")
+		err = v.Set("rFKbo:10")
 		assert.Nil(t, err)
-		err = v.Set("Qvoja20")
+		err = v.Set("biQMq20")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("JOzDp:20")
+		err = v.Set("SDfoO:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]uint", v.Type())
@@ -1467,9 +1467,9 @@ func TestStringUintMapValue(t *testing.T) {
 		v := newStringUintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("aNUHv-1")
+		err = v.Set("qwrmY-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("FhXzh:-1")
+		err = v.Set("lrHNu:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]uint", v.Type())
@@ -1484,13 +1484,13 @@ func TestIntUintMapValue(t *testing.T) {
 		v := newIntUintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("0:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
@@ -1506,11 +1506,11 @@ func TestIntUintMapValue(t *testing.T) {
 		v := newIntUintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7-1")
+		err = v.Set("5-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("4:-1")
+		err = v.Set("2:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]uint", v.Type())
@@ -1525,17 +1525,17 @@ func TestInt8UintMapValue(t *testing.T) {
 		v := newInt8UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("310")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("3:10")
 		assert.Nil(t, err)
-		err = v.Set("320")
+		err = v.Set("620")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]uint", v.Type())
@@ -1547,11 +1547,11 @@ func TestInt8UintMapValue(t *testing.T) {
 		v := newInt8UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6-1")
+		err = v.Set("0-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("6:-1")
+		err = v.Set("3:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]uint", v.Type())
@@ -1566,11 +1566,11 @@ func TestInt16UintMapValue(t *testing.T) {
 		v := newInt16UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610")
+		err = v.Set("510")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("7:10")
+		err = v.Set("3:10")
 		assert.Nil(t, err)
 		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
@@ -1588,11 +1588,11 @@ func TestInt16UintMapValue(t *testing.T) {
 		v := newInt16UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1-1")
+		err = v.Set("6-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("7:-1")
+		err = v.Set("4:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]uint", v.Type())
@@ -1607,13 +1607,13 @@ func TestInt32UintMapValue(t *testing.T) {
 		v := newInt32UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("7:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
@@ -1629,11 +1629,11 @@ func TestInt32UintMapValue(t *testing.T) {
 		v := newInt32UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7-1")
+		err = v.Set("0-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("5:-1")
+		err = v.Set("3:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]uint", v.Type())
@@ -1648,17 +1648,17 @@ func TestInt64UintMapValue(t *testing.T) {
 		v := newInt64UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("320")
+		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("6:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]uint", v.Type())
@@ -1670,11 +1670,11 @@ func TestInt64UintMapValue(t *testing.T) {
 		v := newInt64UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0-1")
+		err = v.Set("4-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("0:-1")
+		err = v.Set("6:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]uint", v.Type())
@@ -1689,17 +1689,17 @@ func TestUintUintMapValue(t *testing.T) {
 		v := newUintUintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("610")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
 		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("3:20")
+		err = v.Set("7:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]uint", v.Type())
@@ -1711,11 +1711,11 @@ func TestUintUintMapValue(t *testing.T) {
 		v := newUintUintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5-1")
+		err = v.Set("2-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("7:-1")
+		err = v.Set("1:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]uint", v.Type())
@@ -1730,17 +1730,17 @@ func TestUint8UintMapValue(t *testing.T) {
 		v := newUint8UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
 		err = v.Set("4:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("520")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("2:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]uint", v.Type())
@@ -1752,7 +1752,7 @@ func TestUint8UintMapValue(t *testing.T) {
 		v := newUint8UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1-1")
+		err = v.Set("6-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
@@ -1771,13 +1771,13 @@ func TestUint16UintMapValue(t *testing.T) {
 		v := newUint16UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("310")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("7:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("320")
+		err = v.Set("520")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
@@ -1793,11 +1793,11 @@ func TestUint16UintMapValue(t *testing.T) {
 		v := newUint16UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5-1")
+		err = v.Set("3-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("4:-1")
+		err = v.Set("5:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]uint", v.Type())
@@ -1812,17 +1812,17 @@ func TestUint32UintMapValue(t *testing.T) {
 		v := newUint32UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("1:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]uint", v.Type())
@@ -1834,11 +1834,11 @@ func TestUint32UintMapValue(t *testing.T) {
 		v := newUint32UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2-1")
+		err = v.Set("0-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("7:-1")
+		err = v.Set("6:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]uint", v.Type())
@@ -1853,17 +1853,17 @@ func TestUint64UintMapValue(t *testing.T) {
 		v := newUint64UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("310")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("4:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("3:20")
+		err = v.Set("2:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]uint", v.Type())
@@ -1875,11 +1875,11 @@ func TestUint64UintMapValue(t *testing.T) {
 		v := newUint64UintMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7-1")
+		err = v.Set("4-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("6:-1")
+		err = v.Set("4:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]uint", v.Type())
@@ -2085,13 +2085,13 @@ func TestStringUint8MapValue(t *testing.T) {
 		v := newStringUint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("lkBMJ10")
+		err = v.Set("qxbQs10")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("vMxai:10")
+		err = v.Set("FgeYF:10")
 		assert.Nil(t, err)
-		err = v.Set("NjAmP20")
+		err = v.Set("tkokN20")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("BqnHu:20")
+		err = v.Set("Yxcii:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]uint8", v.Type())
@@ -2103,9 +2103,9 @@ func TestStringUint8MapValue(t *testing.T) {
 		v := newStringUint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("HxRkr-1")
+		err = v.Set("UUpXP-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("wxdUJ:-1")
+		err = v.Set("rDddw:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]uint8", v.Type())
@@ -2120,17 +2120,17 @@ func TestIntUint8MapValue(t *testing.T) {
 		v := newIntUint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
 		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("6:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]uint8", v.Type())
@@ -2146,7 +2146,7 @@ func TestIntUint8MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("2:-1")
+		err = v.Set("3:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]uint8", v.Type())
@@ -2165,13 +2165,13 @@ func TestInt8Uint8MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("4:10")
+		err = v.Set("3:10")
 		assert.Nil(t, err)
 		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("3:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]uint8", v.Type())
@@ -2183,11 +2183,11 @@ func TestInt8Uint8MapValue(t *testing.T) {
 		v := newInt8Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1-1")
+		err = v.Set("6-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("7:-1")
+		err = v.Set("0:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]uint8", v.Type())
@@ -2202,17 +2202,17 @@ func TestInt16Uint8MapValue(t *testing.T) {
 		v := newInt16Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("0:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]uint8", v.Type())
@@ -2224,11 +2224,11 @@ func TestInt16Uint8MapValue(t *testing.T) {
 		v := newInt16Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0-1")
+		err = v.Set("1-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("1:-1")
+		err = v.Set("3:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]uint8", v.Type())
@@ -2243,17 +2243,17 @@ func TestInt32Uint8MapValue(t *testing.T) {
 		v := newInt32Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("210")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("3:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]uint8", v.Type())
@@ -2265,11 +2265,11 @@ func TestInt32Uint8MapValue(t *testing.T) {
 		v := newInt32Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7-1")
+		err = v.Set("5-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("5:-1")
+		err = v.Set("3:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]uint8", v.Type())
@@ -2284,17 +2284,17 @@ func TestInt64Uint8MapValue(t *testing.T) {
 		v := newInt64Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("510")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("1:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]uint8", v.Type())
@@ -2310,7 +2310,7 @@ func TestInt64Uint8MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("4:-1")
+		err = v.Set("7:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]uint8", v.Type())
@@ -2329,13 +2329,13 @@ func TestUintUint8MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("3:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("120")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("3:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]uint8", v.Type())
@@ -2347,11 +2347,11 @@ func TestUintUint8MapValue(t *testing.T) {
 		v := newUintUint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1-1")
+		err = v.Set("5-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("6:-1")
+		err = v.Set("4:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]uint8", v.Type())
@@ -2366,17 +2366,17 @@ func TestUint8Uint8MapValue(t *testing.T) {
 		v := newUint8Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("1:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("120")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("2:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]uint8", v.Type())
@@ -2392,7 +2392,7 @@ func TestUint8Uint8MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("4:-1")
+		err = v.Set("3:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]uint8", v.Type())
@@ -2407,17 +2407,17 @@ func TestUint16Uint8MapValue(t *testing.T) {
 		v := newUint16Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("610")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("0:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
 		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("4:20")
+		err = v.Set("7:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]uint8", v.Type())
@@ -2429,11 +2429,11 @@ func TestUint16Uint8MapValue(t *testing.T) {
 		v := newUint16Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7-1")
+		err = v.Set("3-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("6:-1")
+		err = v.Set("3:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]uint8", v.Type())
@@ -2448,17 +2448,17 @@ func TestUint32Uint8MapValue(t *testing.T) {
 		v := newUint32Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("210")
+		err = v.Set("310")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]uint8", v.Type())
@@ -2470,11 +2470,11 @@ func TestUint32Uint8MapValue(t *testing.T) {
 		v := newUint32Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0-1")
+		err = v.Set("7-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("4:-1")
+		err = v.Set("7:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]uint8", v.Type())
@@ -2489,17 +2489,17 @@ func TestUint64Uint8MapValue(t *testing.T) {
 		v := newUint64Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("310")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("3:10")
 		assert.Nil(t, err)
-		err = v.Set("120")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("4:20")
+		err = v.Set("5:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]uint8", v.Type())
@@ -2511,11 +2511,11 @@ func TestUint64Uint8MapValue(t *testing.T) {
 		v := newUint64Uint8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4-1")
+		err = v.Set("3-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("5:-1")
+		err = v.Set("7:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]uint8", v.Type())
@@ -2721,13 +2721,13 @@ func TestStringUint16MapValue(t *testing.T) {
 		v := newStringUint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("aWbPd10")
+		err = v.Set("cCMEf10")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("fxYeD:10")
+		err = v.Set("MINCC:10")
 		assert.Nil(t, err)
-		err = v.Set("CzbXP20")
+		err = v.Set("Unuhm20")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("gRoVH:20")
+		err = v.Set("gHNjr:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]uint16", v.Type())
@@ -2739,9 +2739,9 @@ func TestStringUint16MapValue(t *testing.T) {
 		v := newStringUint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("hyiEE-1")
+		err = v.Set("QpOWW-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("tJjLa:-1")
+		err = v.Set("NKglz:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]uint16", v.Type())
@@ -2756,17 +2756,17 @@ func TestIntUint16MapValue(t *testing.T) {
 		v := newIntUint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("4:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("320")
+		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("7:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]uint16", v.Type())
@@ -2778,11 +2778,11 @@ func TestIntUint16MapValue(t *testing.T) {
 		v := newIntUint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7-1")
+		err = v.Set("5-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("1:-1")
+		err = v.Set("0:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]uint16", v.Type())
@@ -2797,17 +2797,17 @@ func TestInt8Uint16MapValue(t *testing.T) {
 		v := newInt8Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("7:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
 		err = v.Set("120")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]uint16", v.Type())
@@ -2819,11 +2819,11 @@ func TestInt8Uint16MapValue(t *testing.T) {
 		v := newInt8Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2-1")
+		err = v.Set("1-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("4:-1")
+		err = v.Set("2:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]uint16", v.Type())
@@ -2838,13 +2838,13 @@ func TestInt16Uint16MapValue(t *testing.T) {
 		v := newInt16Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("3:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("520")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
@@ -2860,11 +2860,11 @@ func TestInt16Uint16MapValue(t *testing.T) {
 		v := newInt16Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0-1")
+		err = v.Set("2-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("6:-1")
+		err = v.Set("2:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]uint16", v.Type())
@@ -2879,17 +2879,17 @@ func TestInt32Uint16MapValue(t *testing.T) {
 		v := newInt32Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("4:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]uint16", v.Type())
@@ -2901,11 +2901,11 @@ func TestInt32Uint16MapValue(t *testing.T) {
 		v := newInt32Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6-1")
+		err = v.Set("7-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("6:-1")
+		err = v.Set("4:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]uint16", v.Type())
@@ -2920,17 +2920,17 @@ func TestInt64Uint16MapValue(t *testing.T) {
 		v := newInt64Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010")
+		err = v.Set("510")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("620")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]uint16", v.Type())
@@ -2942,11 +2942,11 @@ func TestInt64Uint16MapValue(t *testing.T) {
 		v := newInt64Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0-1")
+		err = v.Set("6-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("1:-1")
+		err = v.Set("6:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]uint16", v.Type())
@@ -2961,17 +2961,17 @@ func TestUintUint16MapValue(t *testing.T) {
 		v := newUintUint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("120")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("2:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]uint16", v.Type())
@@ -2983,11 +2983,11 @@ func TestUintUint16MapValue(t *testing.T) {
 		v := newUintUint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0-1")
+		err = v.Set("6-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("2:-1")
+		err = v.Set("4:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]uint16", v.Type())
@@ -3002,17 +3002,17 @@ func TestUint8Uint16MapValue(t *testing.T) {
 		v := newUint8Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610")
+		err = v.Set("310")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("4:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("520")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("7:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]uint16", v.Type())
@@ -3024,11 +3024,11 @@ func TestUint8Uint16MapValue(t *testing.T) {
 		v := newUint8Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0-1")
+		err = v.Set("3-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("4:-1")
+		err = v.Set("1:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]uint16", v.Type())
@@ -3043,17 +3043,17 @@ func TestUint16Uint16MapValue(t *testing.T) {
 		v := newUint16Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010")
+		err = v.Set("310")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("1:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("4:20")
+		err = v.Set("5:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]uint16", v.Type())
@@ -3065,11 +3065,11 @@ func TestUint16Uint16MapValue(t *testing.T) {
 		v := newUint16Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6-1")
+		err = v.Set("7-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("4:-1")
+		err = v.Set("2:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]uint16", v.Type())
@@ -3084,17 +3084,17 @@ func TestUint32Uint16MapValue(t *testing.T) {
 		v := newUint32Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("620")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("6:20")
+		err = v.Set("2:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]uint16", v.Type())
@@ -3106,7 +3106,7 @@ func TestUint32Uint16MapValue(t *testing.T) {
 		v := newUint32Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1-1")
+		err = v.Set("0-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
@@ -3125,17 +3125,17 @@ func TestUint64Uint16MapValue(t *testing.T) {
 		v := newUint64Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("210")
+		err = v.Set("110")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("4:10")
+		err = v.Set("0:10")
 		assert.Nil(t, err)
-		err = v.Set("320")
+		err = v.Set("520")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]uint16", v.Type())
@@ -3147,11 +3147,11 @@ func TestUint64Uint16MapValue(t *testing.T) {
 		v := newUint64Uint16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2-1")
+		err = v.Set("1-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("1:-1")
+		err = v.Set("6:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]uint16", v.Type())
@@ -3357,13 +3357,13 @@ func TestStringUint32MapValue(t *testing.T) {
 		v := newStringUint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("rRSCT10")
+		err = v.Set("EVXYF10")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("qCqRG:10")
+		err = v.Set("JjvfF:10")
 		assert.Nil(t, err)
-		err = v.Set("tgLNl20")
+		err = v.Set("mwoJb20")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("MfWnI:20")
+		err = v.Set("ZFZqU:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]uint32", v.Type())
@@ -3375,9 +3375,9 @@ func TestStringUint32MapValue(t *testing.T) {
 		v := newStringUint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("Ugjzx-1")
+		err = v.Set("CZutW-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("LinnY:-1")
+		err = v.Set("OWbBF:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]uint32", v.Type())
@@ -3392,17 +3392,17 @@ func TestIntUint32MapValue(t *testing.T) {
 		v := newIntUint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("4:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("2:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]uint32", v.Type())
@@ -3414,11 +3414,11 @@ func TestIntUint32MapValue(t *testing.T) {
 		v := newIntUint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6-1")
+		err = v.Set("0-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("6:-1")
+		err = v.Set("0:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]uint32", v.Type())
@@ -3433,17 +3433,17 @@ func TestInt8Uint32MapValue(t *testing.T) {
 		v := newInt8Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("610")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("1:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]uint32", v.Type())
@@ -3455,11 +3455,11 @@ func TestInt8Uint32MapValue(t *testing.T) {
 		v := newInt8Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3-1")
+		err = v.Set("5-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("4:-1")
+		err = v.Set("0:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]uint32", v.Type())
@@ -3474,17 +3474,17 @@ func TestInt16Uint32MapValue(t *testing.T) {
 		v := newInt16Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
 		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("6:20")
+		err = v.Set("5:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]uint32", v.Type())
@@ -3496,7 +3496,7 @@ func TestInt16Uint32MapValue(t *testing.T) {
 		v := newInt16Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1-1")
+		err = v.Set("5-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
@@ -3515,17 +3515,17 @@ func TestInt32Uint32MapValue(t *testing.T) {
 		v := newInt32Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010")
+		err = v.Set("110")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
 		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("3:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]uint32", v.Type())
@@ -3537,11 +3537,11 @@ func TestInt32Uint32MapValue(t *testing.T) {
 		v := newInt32Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2-1")
+		err = v.Set("7-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("7:-1")
+		err = v.Set("2:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]uint32", v.Type())
@@ -3560,13 +3560,13 @@ func TestInt64Uint32MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("1:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
-		err = v.Set("120")
+		err = v.Set("620")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("6:20")
+		err = v.Set("1:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]uint32", v.Type())
@@ -3578,11 +3578,11 @@ func TestInt64Uint32MapValue(t *testing.T) {
 		v := newInt64Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1-1")
+		err = v.Set("3-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("0:-1")
+		err = v.Set("4:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]uint32", v.Type())
@@ -3597,17 +3597,17 @@ func TestUintUint32MapValue(t *testing.T) {
 		v := newUintUint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("7:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
 		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("2:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]uint32", v.Type())
@@ -3619,11 +3619,11 @@ func TestUintUint32MapValue(t *testing.T) {
 		v := newUintUint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1-1")
+		err = v.Set("5-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("2:-1")
+		err = v.Set("4:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]uint32", v.Type())
@@ -3638,17 +3638,17 @@ func TestUint8Uint32MapValue(t *testing.T) {
 		v := newUint8Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("610")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("1:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("1:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]uint32", v.Type())
@@ -3660,11 +3660,11 @@ func TestUint8Uint32MapValue(t *testing.T) {
 		v := newUint8Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4-1")
+		err = v.Set("6-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("6:-1")
+		err = v.Set("4:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]uint32", v.Type())
@@ -3679,17 +3679,17 @@ func TestUint16Uint32MapValue(t *testing.T) {
 		v := newUint16Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010")
+		err = v.Set("410")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("7:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("520")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("7:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]uint32", v.Type())
@@ -3701,7 +3701,7 @@ func TestUint16Uint32MapValue(t *testing.T) {
 		v := newUint16Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6-1")
+		err = v.Set("1-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
@@ -3724,9 +3724,9 @@ func TestUint32Uint32MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
@@ -3742,11 +3742,11 @@ func TestUint32Uint32MapValue(t *testing.T) {
 		v := newUint32Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3-1")
+		err = v.Set("4-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("4:-1")
+		err = v.Set("0:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]uint32", v.Type())
@@ -3761,17 +3761,17 @@ func TestUint64Uint32MapValue(t *testing.T) {
 		v := newUint64Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010")
+		err = v.Set("610")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("2:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]uint32", v.Type())
@@ -3783,11 +3783,11 @@ func TestUint64Uint32MapValue(t *testing.T) {
 		v := newUint64Uint32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3-1")
+		err = v.Set("1-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("7:-1")
+		err = v.Set("3:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]uint32", v.Type())
@@ -3993,13 +3993,13 @@ func TestStringUint64MapValue(t *testing.T) {
 		v := newStringUint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("Ynkph10")
+		err = v.Set("cfnSM10")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("JtETa:10")
+		err = v.Set("JNMZa:10")
 		assert.Nil(t, err)
-		err = v.Set("TIlsU20")
+		err = v.Set("siCln20")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("MpMcH:20")
+		err = v.Set("bAmgS:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]uint64", v.Type())
@@ -4011,9 +4011,9 @@ func TestStringUint64MapValue(t *testing.T) {
 		v := newStringUint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("oLfCf-1")
+		err = v.Set("EbeZl-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("zJUJB:-1")
+		err = v.Set("sziRO:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]uint64", v.Type())
@@ -4028,17 +4028,17 @@ func TestIntUint64MapValue(t *testing.T) {
 		v := newIntUint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("720")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("3:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]uint64", v.Type())
@@ -4050,11 +4050,11 @@ func TestIntUint64MapValue(t *testing.T) {
 		v := newIntUint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0-1")
+		err = v.Set("3-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("0:-1")
+		err = v.Set("3:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]uint64", v.Type())
@@ -4069,17 +4069,17 @@ func TestInt8Uint64MapValue(t *testing.T) {
 		v := newInt8Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("510")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("7:10")
+		err = v.Set("3:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("120")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]uint64", v.Type())
@@ -4091,11 +4091,11 @@ func TestInt8Uint64MapValue(t *testing.T) {
 		v := newInt8Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5-1")
+		err = v.Set("3-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("3:-1")
+		err = v.Set("6:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]uint64", v.Type())
@@ -4110,17 +4110,17 @@ func TestInt16Uint64MapValue(t *testing.T) {
 		v := newInt16Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("510")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("5:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]uint64", v.Type())
@@ -4132,11 +4132,11 @@ func TestInt16Uint64MapValue(t *testing.T) {
 		v := newInt16Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6-1")
+		err = v.Set("3-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("5:-1")
+		err = v.Set("2:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]uint64", v.Type())
@@ -4151,17 +4151,17 @@ func TestInt32Uint64MapValue(t *testing.T) {
 		v := newInt32Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("210")
+		err = v.Set("110")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("3:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]uint64", v.Type())
@@ -4173,11 +4173,11 @@ func TestInt32Uint64MapValue(t *testing.T) {
 		v := newInt32Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3-1")
+		err = v.Set("5-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("3:-1")
+		err = v.Set("0:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]uint64", v.Type())
@@ -4192,13 +4192,13 @@ func TestInt64Uint64MapValue(t *testing.T) {
 		v := newInt64Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("210")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
@@ -4214,11 +4214,11 @@ func TestInt64Uint64MapValue(t *testing.T) {
 		v := newInt64Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6-1")
+		err = v.Set("4-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("1:-1")
+		err = v.Set("6:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]uint64", v.Type())
@@ -4237,9 +4237,9 @@ func TestUintUint64MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("0:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
@@ -4255,11 +4255,11 @@ func TestUintUint64MapValue(t *testing.T) {
 		v := newUintUint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3-1")
+		err = v.Set("2-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("5:-1")
+		err = v.Set("6:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]uint64", v.Type())
@@ -4274,17 +4274,17 @@ func TestUint8Uint64MapValue(t *testing.T) {
 		v := newUint8Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
 		err = v.Set("3:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("7:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]uint64", v.Type())
@@ -4296,11 +4296,11 @@ func TestUint8Uint64MapValue(t *testing.T) {
 		v := newUint8Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7-1")
+		err = v.Set("1-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("2:-1")
+		err = v.Set("1:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]uint64", v.Type())
@@ -4315,17 +4315,17 @@ func TestUint16Uint64MapValue(t *testing.T) {
 		v := newUint16Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("3:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]uint64", v.Type())
@@ -4337,11 +4337,11 @@ func TestUint16Uint64MapValue(t *testing.T) {
 		v := newUint16Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3-1")
+		err = v.Set("0-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("5:-1")
+		err = v.Set("3:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]uint64", v.Type())
@@ -4356,17 +4356,17 @@ func TestUint32Uint64MapValue(t *testing.T) {
 		v := newUint32Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("310")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]uint64", v.Type())
@@ -4378,11 +4378,11 @@ func TestUint32Uint64MapValue(t *testing.T) {
 		v := newUint32Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5-1")
+		err = v.Set("0-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("5:-1")
+		err = v.Set("0:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]uint64", v.Type())
@@ -4397,17 +4397,17 @@ func TestUint64Uint64MapValue(t *testing.T) {
 		v := newUint64Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
 		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]uint64", v.Type())
@@ -4419,11 +4419,11 @@ func TestUint64Uint64MapValue(t *testing.T) {
 		v := newUint64Uint64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0-1")
+		err = v.Set("2-1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":-1")
 		assert.NotNil(t, err)
-		err = v.Set("0:-1")
+		err = v.Set("4:-1")
 		assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]uint64", v.Type())
@@ -4669,13 +4669,13 @@ func TestStringIntMapValue(t *testing.T) {
 		v := newStringIntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("HVsTf10")
+		err = v.Set("dekJz10")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("qzbLs:10")
+		err = v.Set("gGrVM:10")
 		assert.Nil(t, err)
-		err = v.Set("fVYzM20")
+		err = v.Set("IWaYa20")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("qPpCS:20")
+		err = v.Set("oFGzL:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]int", v.Type())
@@ -4687,9 +4687,9 @@ func TestStringIntMapValue(t *testing.T) {
 		v := newStringIntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("fJUBya")
+		err = v.Set("PIiQna")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("uuoIX:a")
+		err = v.Set("nrFzc:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]int", v.Type())
@@ -4704,17 +4704,17 @@ func TestIntIntMapValue(t *testing.T) {
 		v := newIntIntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("310")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("0:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]int", v.Type())
@@ -4745,17 +4745,17 @@ func TestInt8IntMapValue(t *testing.T) {
 		v := newInt8IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("110")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("4:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("3:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]int", v.Type())
@@ -4767,11 +4767,11 @@ func TestInt8IntMapValue(t *testing.T) {
 		v := newInt8IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6a")
+		err = v.Set("1a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("2:a")
+		err = v.Set("1:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]int", v.Type())
@@ -4786,17 +4786,17 @@ func TestInt16IntMapValue(t *testing.T) {
 		v := newInt16IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("410")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]int", v.Type())
@@ -4808,11 +4808,11 @@ func TestInt16IntMapValue(t *testing.T) {
 		v := newInt16IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6a")
+		err = v.Set("2a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("4:a")
+		err = v.Set("2:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]int", v.Type())
@@ -4827,17 +4827,17 @@ func TestInt32IntMapValue(t *testing.T) {
 		v := newInt32IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("620")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("6:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]int", v.Type())
@@ -4849,11 +4849,11 @@ func TestInt32IntMapValue(t *testing.T) {
 		v := newInt32IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("5:a")
+		err = v.Set("2:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]int", v.Type())
@@ -4868,17 +4868,17 @@ func TestInt64IntMapValue(t *testing.T) {
 		v := newInt64IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("410")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("0:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
 		err = v.Set("620")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("3:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]int", v.Type())
@@ -4890,11 +4890,11 @@ func TestInt64IntMapValue(t *testing.T) {
 		v := newInt64IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7a")
+		err = v.Set("5a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("5:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]int", v.Type())
@@ -4909,17 +4909,17 @@ func TestUintIntMapValue(t *testing.T) {
 		v := newUintIntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("410")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("0:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("2:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]int", v.Type())
@@ -4931,11 +4931,11 @@ func TestUintIntMapValue(t *testing.T) {
 		v := newUintIntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("4:a")
+		err = v.Set("7:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]int", v.Type())
@@ -4950,17 +4950,17 @@ func TestUint8IntMapValue(t *testing.T) {
 		v := newUint8IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("110")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("4:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("6:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]int", v.Type())
@@ -4972,11 +4972,11 @@ func TestUint8IntMapValue(t *testing.T) {
 		v := newUint8IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0a")
+		err = v.Set("4a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("0:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]int", v.Type())
@@ -4991,17 +4991,17 @@ func TestUint16IntMapValue(t *testing.T) {
 		v := newUint16IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("1:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("4:20")
+		err = v.Set("3:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]int", v.Type())
@@ -5013,7 +5013,7 @@ func TestUint16IntMapValue(t *testing.T) {
 		v := newUint16IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
@@ -5032,17 +5032,17 @@ func TestUint32IntMapValue(t *testing.T) {
 		v := newUint32IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]int", v.Type())
@@ -5054,11 +5054,11 @@ func TestUint32IntMapValue(t *testing.T) {
 		v := newUint32IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1a")
+		err = v.Set("6a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("1:a")
+		err = v.Set("4:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]int", v.Type())
@@ -5073,11 +5073,11 @@ func TestUint64IntMapValue(t *testing.T) {
 		v := newUint64IntMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("1:10")
+		err = v.Set("4:10")
 		assert.Nil(t, err)
 		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
@@ -5099,7 +5099,7 @@ func TestUint64IntMapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("6:a")
+		err = v.Set("3:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]int", v.Type())
@@ -5315,13 +5315,13 @@ func TestStringInt8MapValue(t *testing.T) {
 		v := newStringInt8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("iOPrg10")
+		err = v.Set("JCDsl10")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("rndrW:10")
+		err = v.Set("OMKzb:10")
 		assert.Nil(t, err)
-		err = v.Set("HxSDh20")
+		err = v.Set("nnPAH20")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("VaTuR:20")
+		err = v.Set("qHaxF:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]int8", v.Type())
@@ -5333,9 +5333,9 @@ func TestStringInt8MapValue(t *testing.T) {
 		v := newStringInt8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("PMVjba")
+		err = v.Set("zpuHGa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("kuWVP:a")
+		err = v.Set("nQdDX:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]int8", v.Type())
@@ -5350,17 +5350,17 @@ func TestIntInt8MapValue(t *testing.T) {
 		v := newIntInt8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("7:10")
+		err = v.Set("4:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("120")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("4:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]int8", v.Type())
@@ -5372,11 +5372,11 @@ func TestIntInt8MapValue(t *testing.T) {
 		v := newIntInt8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2a")
+		err = v.Set("6a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("6:a")
+		err = v.Set("1:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]int8", v.Type())
@@ -5391,13 +5391,13 @@ func TestInt8Int8MapValue(t *testing.T) {
 		v := newInt8Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("0:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("620")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
@@ -5413,11 +5413,11 @@ func TestInt8Int8MapValue(t *testing.T) {
 		v := newInt8Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("2:a")
+		err = v.Set("7:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]int8", v.Type())
@@ -5436,13 +5436,13 @@ func TestInt16Int8MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("1:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("620")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]int8", v.Type())
@@ -5454,7 +5454,7 @@ func TestInt16Int8MapValue(t *testing.T) {
 		v := newInt16Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1a")
+		err = v.Set("2a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
@@ -5473,13 +5473,13 @@ func TestInt32Int8MapValue(t *testing.T) {
 		v := newInt32Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
 		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
@@ -5495,11 +5495,11 @@ func TestInt32Int8MapValue(t *testing.T) {
 		v := newInt32Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7a")
+		err = v.Set("1a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("2:a")
+		err = v.Set("1:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]int8", v.Type())
@@ -5514,17 +5514,17 @@ func TestInt64Int8MapValue(t *testing.T) {
 		v := newInt64Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("4:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("3:20")
+		err = v.Set("1:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]int8", v.Type())
@@ -5536,7 +5536,7 @@ func TestInt64Int8MapValue(t *testing.T) {
 		v := newInt64Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1a")
+		err = v.Set("4a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
@@ -5555,17 +5555,17 @@ func TestUintInt8MapValue(t *testing.T) {
 		v := newUintInt8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("520")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("7:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]int8", v.Type())
@@ -5577,11 +5577,11 @@ func TestUintInt8MapValue(t *testing.T) {
 		v := newUintInt8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7a")
+		err = v.Set("6a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("1:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]int8", v.Type())
@@ -5600,13 +5600,13 @@ func TestUint8Int8MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]int8", v.Type())
@@ -5618,7 +5618,7 @@ func TestUint8Int8MapValue(t *testing.T) {
 		v := newUint8Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
@@ -5637,17 +5637,17 @@ func TestUint16Int8MapValue(t *testing.T) {
 		v := newUint16Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("510")
+		err = v.Set("110")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("620")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("6:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]int8", v.Type())
@@ -5659,11 +5659,11 @@ func TestUint16Int8MapValue(t *testing.T) {
 		v := newUint16Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3a")
+		err = v.Set("4a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("4:a")
+		err = v.Set("5:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]int8", v.Type())
@@ -5678,11 +5678,11 @@ func TestUint32Int8MapValue(t *testing.T) {
 		v := newUint32Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("610")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
 		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
@@ -5700,11 +5700,11 @@ func TestUint32Int8MapValue(t *testing.T) {
 		v := newUint32Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("4:a")
+		err = v.Set("7:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]int8", v.Type())
@@ -5719,17 +5719,17 @@ func TestUint64Int8MapValue(t *testing.T) {
 		v := newUint64Int8MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("410")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]int8", v.Type())
@@ -5745,7 +5745,7 @@ func TestUint64Int8MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("0:a")
+		err = v.Set("5:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]int8", v.Type())
@@ -5961,13 +5961,13 @@ func TestStringInt16MapValue(t *testing.T) {
 		v := newStringInt16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("hAnpH10")
+		err = v.Set("DjljB10")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("KVDnT:10")
+		err = v.Set("TVMGd:10")
 		assert.Nil(t, err)
-		err = v.Set("XCcdg20")
+		err = v.Set("lGQiL20")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("bBjFj:20")
+		err = v.Set("OjHTD:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]int16", v.Type())
@@ -5979,9 +5979,9 @@ func TestStringInt16MapValue(t *testing.T) {
 		v := newStringInt16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("rzOnGa")
+		err = v.Set("JUkAGa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("zJovW:a")
+		err = v.Set("LHQTT:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]int16", v.Type())
@@ -5996,17 +5996,17 @@ func TestIntInt16MapValue(t *testing.T) {
 		v := newIntInt16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010")
+		err = v.Set("510")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]int16", v.Type())
@@ -6018,11 +6018,11 @@ func TestIntInt16MapValue(t *testing.T) {
 		v := newIntInt16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7a")
+		err = v.Set("4a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("0:a")
+		err = v.Set("4:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]int16", v.Type())
@@ -6037,17 +6037,17 @@ func TestInt8Int16MapValue(t *testing.T) {
 		v := newInt8Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610")
+		err = v.Set("410")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("4:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("3:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]int16", v.Type())
@@ -6059,11 +6059,11 @@ func TestInt8Int16MapValue(t *testing.T) {
 		v := newInt8Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3a")
+		err = v.Set("5a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("1:a")
+		err = v.Set("4:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]int16", v.Type())
@@ -6078,17 +6078,17 @@ func TestInt16Int16MapValue(t *testing.T) {
 		v := newInt16Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("1:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("4:20")
+		err = v.Set("5:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]int16", v.Type())
@@ -6100,11 +6100,11 @@ func TestInt16Int16MapValue(t *testing.T) {
 		v := newInt16Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6a")
+		err = v.Set("2a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("1:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]int16", v.Type())
@@ -6119,17 +6119,17 @@ func TestInt32Int16MapValue(t *testing.T) {
 		v := newInt32Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]int16", v.Type())
@@ -6141,11 +6141,11 @@ func TestInt32Int16MapValue(t *testing.T) {
 		v := newInt32Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7a")
+		err = v.Set("2a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("6:a")
+		err = v.Set("2:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]int16", v.Type())
@@ -6164,13 +6164,13 @@ func TestInt64Int16MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("4:10")
 		assert.Nil(t, err)
-		err = v.Set("120")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("4:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]int16", v.Type())
@@ -6186,7 +6186,7 @@ func TestInt64Int16MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("2:a")
+		err = v.Set("1:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]int16", v.Type())
@@ -6201,17 +6201,17 @@ func TestUintInt16MapValue(t *testing.T) {
 		v := newUintInt16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("6:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("720")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]int16", v.Type())
@@ -6223,11 +6223,11 @@ func TestUintInt16MapValue(t *testing.T) {
 		v := newUintInt16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2a")
+		err = v.Set("6a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("0:a")
+		err = v.Set("3:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]int16", v.Type())
@@ -6242,17 +6242,17 @@ func TestUint8Int16MapValue(t *testing.T) {
 		v := newUint8Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("7:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("5:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]int16", v.Type())
@@ -6264,11 +6264,11 @@ func TestUint8Int16MapValue(t *testing.T) {
 		v := newUint8Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6a")
+		err = v.Set("7a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("6:a")
+		err = v.Set("3:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]int16", v.Type())
@@ -6283,17 +6283,17 @@ func TestUint16Int16MapValue(t *testing.T) {
 		v := newUint16Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("4:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]int16", v.Type())
@@ -6309,7 +6309,7 @@ func TestUint16Int16MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("0:a")
+		err = v.Set("4:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]int16", v.Type())
@@ -6324,17 +6324,17 @@ func TestUint32Int16MapValue(t *testing.T) {
 		v := newUint32Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]int16", v.Type())
@@ -6346,11 +6346,11 @@ func TestUint32Int16MapValue(t *testing.T) {
 		v := newUint32Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0a")
+		err = v.Set("7a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("7:a")
+		err = v.Set("5:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]int16", v.Type())
@@ -6365,17 +6365,17 @@ func TestUint64Int16MapValue(t *testing.T) {
 		v := newUint64Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610")
+		err = v.Set("310")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("620")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("7:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]int16", v.Type())
@@ -6387,11 +6387,11 @@ func TestUint64Int16MapValue(t *testing.T) {
 		v := newUint64Int16MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("1:a")
+		err = v.Set("4:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]int16", v.Type())
@@ -6607,13 +6607,13 @@ func TestStringInt32MapValue(t *testing.T) {
 		v := newStringInt32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("OFaXx10")
+		err = v.Set("xnutA10")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("bOZZv:10")
+		err = v.Set("WCqYP:10")
 		assert.Nil(t, err)
-		err = v.Set("wKMHM20")
+		err = v.Set("JSElL20")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("uDqyA:20")
+		err = v.Set("uldGZ:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]int32", v.Type())
@@ -6625,9 +6625,9 @@ func TestStringInt32MapValue(t *testing.T) {
 		v := newStringInt32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("FrWVfa")
+		err = v.Set("nNtMta")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("glgQW:a")
+		err = v.Set("gLxNq:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]int32", v.Type())
@@ -6642,17 +6642,17 @@ func TestIntInt32MapValue(t *testing.T) {
 		v := newIntInt32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("110")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("1:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("7:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]int32", v.Type())
@@ -6664,11 +6664,11 @@ func TestIntInt32MapValue(t *testing.T) {
 		v := newIntInt32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("4:a")
+		err = v.Set("6:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]int32", v.Type())
@@ -6689,11 +6689,11 @@ func TestInt8Int32MapValue(t *testing.T) {
 		assert.NotNil(t, err)
 		err = v.Set("5:10")
 		assert.Nil(t, err)
-		err = v.Set("320")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("3:20")
+		err = v.Set("1:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]int32", v.Type())
@@ -6705,7 +6705,7 @@ func TestInt8Int32MapValue(t *testing.T) {
 		v := newInt8Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3a")
+		err = v.Set("6a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
@@ -6724,17 +6724,17 @@ func TestInt16Int32MapValue(t *testing.T) {
 		v := newInt16Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("4:10")
 		assert.Nil(t, err)
 		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]int32", v.Type())
@@ -6746,11 +6746,11 @@ func TestInt16Int32MapValue(t *testing.T) {
 		v := newInt16Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0a")
+		err = v.Set("2a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("4:a")
+		err = v.Set("3:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]int32", v.Type())
@@ -6765,17 +6765,17 @@ func TestInt32Int32MapValue(t *testing.T) {
 		v := newInt32Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
 		err = v.Set("0:10")
 		assert.Nil(t, err)
-		err = v.Set("720")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]int32", v.Type())
@@ -6787,11 +6787,11 @@ func TestInt32Int32MapValue(t *testing.T) {
 		v := newInt32Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("4:a")
+		err = v.Set("3:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]int32", v.Type())
@@ -6810,13 +6810,13 @@ func TestInt64Int32MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("0:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]int32", v.Type())
@@ -6828,11 +6828,11 @@ func TestInt64Int32MapValue(t *testing.T) {
 		v := newInt64Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1a")
+		err = v.Set("7a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("0:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]int32", v.Type())
@@ -6847,17 +6847,17 @@ func TestUintInt32MapValue(t *testing.T) {
 		v := newUintInt32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("510")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("7:10")
+		err = v.Set("4:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("3:20")
+		err = v.Set("1:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]int32", v.Type())
@@ -6869,11 +6869,11 @@ func TestUintInt32MapValue(t *testing.T) {
 		v := newUintInt32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1a")
+		err = v.Set("7a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("6:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]int32", v.Type())
@@ -6888,17 +6888,17 @@ func TestUint8Int32MapValue(t *testing.T) {
 		v := newUint8Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("2:10")
 		assert.Nil(t, err)
-		err = v.Set("220")
+		err = v.Set("120")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]int32", v.Type())
@@ -6910,11 +6910,11 @@ func TestUint8Int32MapValue(t *testing.T) {
 		v := newUint8Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("6:a")
+		err = v.Set("2:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]int32", v.Type())
@@ -6929,17 +6929,17 @@ func TestUint16Int32MapValue(t *testing.T) {
 		v := newUint16Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("610")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("0:10")
 		assert.Nil(t, err)
-		err = v.Set("320")
+		err = v.Set("520")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("6:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]int32", v.Type())
@@ -6951,11 +6951,11 @@ func TestUint16Int32MapValue(t *testing.T) {
 		v := newUint16Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("1:a")
+		err = v.Set("3:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]int32", v.Type())
@@ -6970,17 +6970,17 @@ func TestUint32Int32MapValue(t *testing.T) {
 		v := newUint32Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("420")
+		err = v.Set("120")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("3:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]int32", v.Type())
@@ -6992,11 +6992,11 @@ func TestUint32Int32MapValue(t *testing.T) {
 		v := newUint32Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3a")
+		err = v.Set("1a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("6:a")
+		err = v.Set("0:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]int32", v.Type())
@@ -7015,13 +7015,13 @@ func TestUint64Int32MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("0:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("5:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]int32", v.Type())
@@ -7033,11 +7033,11 @@ func TestUint64Int32MapValue(t *testing.T) {
 		v := newUint64Int32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("2:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]int32", v.Type())
@@ -7253,13 +7253,13 @@ func TestStringInt64MapValue(t *testing.T) {
 		v := newStringInt64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("Kwidi10")
+		err = v.Set("UUWUt10")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("WiqYf:10")
+		err = v.Set("FbmhA:10")
 		assert.Nil(t, err)
-		err = v.Set("zuXZp20")
+		err = v.Set("RcqTB20")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("cfcEq:20")
+		err = v.Set("ZoFto:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]int64", v.Type())
@@ -7271,9 +7271,9 @@ func TestStringInt64MapValue(t *testing.T) {
 		v := newStringInt64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("EGPMBa")
+		err = v.Set("duzbya")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("sbkWa:a")
+		err = v.Set("XkuLv:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]int64", v.Type())
@@ -7288,17 +7288,17 @@ func TestIntInt64MapValue(t *testing.T) {
 		v := newIntInt64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("210")
+		err = v.Set("010")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
 		err = v.Set("0:10")
 		assert.Nil(t, err)
-		err = v.Set("520")
+		err = v.Set("120")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("4:20")
+		err = v.Set("5:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]int64", v.Type())
@@ -7310,11 +7310,11 @@ func TestIntInt64MapValue(t *testing.T) {
 		v := newIntInt64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("1:a")
+		err = v.Set("5:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]int64", v.Type())
@@ -7333,13 +7333,13 @@ func TestInt8Int64MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("6:10")
 		assert.Nil(t, err)
-		err = v.Set("120")
+		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("0:20")
+		err = v.Set("4:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]int64", v.Type())
@@ -7351,11 +7351,11 @@ func TestInt8Int64MapValue(t *testing.T) {
 		v := newInt8Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6a")
+		err = v.Set("5a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("7:a")
+		err = v.Set("4:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]int64", v.Type())
@@ -7370,17 +7370,17 @@ func TestInt16Int64MapValue(t *testing.T) {
 		v := newInt16Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("5:10")
+		err = v.Set("0:10")
 		assert.Nil(t, err)
-		err = v.Set("720")
+		err = v.Set("420")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("5:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]int64", v.Type())
@@ -7396,7 +7396,7 @@ func TestInt16Int64MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("6:a")
+		err = v.Set("1:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]int64", v.Type())
@@ -7415,13 +7415,13 @@ func TestInt32Int64MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("0:10")
+		err = v.Set("1:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("320")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("2:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]int64", v.Type())
@@ -7433,11 +7433,11 @@ func TestInt32Int64MapValue(t *testing.T) {
 		v := newInt32Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7a")
+		err = v.Set("5a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("2:a")
+		err = v.Set("4:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]int64", v.Type())
@@ -7452,17 +7452,17 @@ func TestInt64Int64MapValue(t *testing.T) {
 		v := newInt64Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("210")
+		err = v.Set("110")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("2:10")
+		err = v.Set("5:10")
 		assert.Nil(t, err)
 		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("1:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]int64", v.Type())
@@ -7474,11 +7474,11 @@ func TestInt64Int64MapValue(t *testing.T) {
 		v := newInt64Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1a")
+		err = v.Set("4a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("5:a")
+		err = v.Set("4:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]int64", v.Type())
@@ -7493,17 +7493,17 @@ func TestUintInt64MapValue(t *testing.T) {
 		v := newUintInt64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310")
+		err = v.Set("610")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("0:10")
+		err = v.Set("3:10")
 		assert.Nil(t, err)
-		err = v.Set("620")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("7:20")
+		err = v.Set("5:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]int64", v.Type())
@@ -7515,7 +7515,7 @@ func TestUintInt64MapValue(t *testing.T) {
 		v := newUintInt64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
@@ -7534,17 +7534,17 @@ func TestUint8Int64MapValue(t *testing.T) {
 		v := newUint8Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("110")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("4:10")
+		err = v.Set("0:10")
 		assert.Nil(t, err)
-		err = v.Set("020")
+		err = v.Set("120")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("5:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]int64", v.Type())
@@ -7556,7 +7556,7 @@ func TestUint8Int64MapValue(t *testing.T) {
 		v := newUint8Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4a")
+		err = v.Set("2a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
@@ -7575,11 +7575,11 @@ func TestUint16Int64MapValue(t *testing.T) {
 		v := newUint16Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110")
+		err = v.Set("210")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
 		err = v.Set("020")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
@@ -7597,11 +7597,11 @@ func TestUint16Int64MapValue(t *testing.T) {
 		v := newUint16Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0a")
+		err = v.Set("6a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("5:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]int64", v.Type())
@@ -7616,17 +7616,17 @@ func TestUint32Int64MapValue(t *testing.T) {
 		v := newUint32Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410")
+		err = v.Set("710")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("4:10")
+		err = v.Set("7:10")
 		assert.Nil(t, err)
-		err = v.Set("720")
+		err = v.Set("220")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("1:20")
+		err = v.Set("2:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]int64", v.Type())
@@ -7638,11 +7638,11 @@ func TestUint32Int64MapValue(t *testing.T) {
 		v := newUint32Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4a")
+		err = v.Set("2a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("1:a")
+		err = v.Set("6:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]int64", v.Type())
@@ -7657,17 +7657,17 @@ func TestUint64Int64MapValue(t *testing.T) {
 		v := newUint64Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710")
+		err = v.Set("410")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10")
 		assert.NotNil(t, err)
-		err = v.Set("3:10")
+		err = v.Set("0:10")
 		assert.Nil(t, err)
-		err = v.Set("120")
+		err = v.Set("720")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20")
 		assert.NotNil(t, err)
-		err = v.Set("4:20")
+		err = v.Set("0:20")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]int64", v.Type())
@@ -7679,11 +7679,11 @@ func TestUint64Int64MapValue(t *testing.T) {
 		v := newUint64Int64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("2:a")
 		assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]int64", v.Type())
@@ -7879,13 +7879,13 @@ func TestStringFloat64MapValue(t *testing.T) {
 		v := newStringFloat64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("EfBGI10.2")
+		err = v.Set("FejRb10.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("vDVDf:10.2")
+		err = v.Set("IFhMx:10.2")
 		assert.Nil(t, err)
-		err = v.Set("RuRcq20.99")
+		err = v.Set("BXidS20.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("FzABr:20.99")
+		err = v.Set("xVHOg:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]float64", v.Type())
@@ -7897,9 +7897,9 @@ func TestStringFloat64MapValue(t *testing.T) {
 		v := newStringFloat64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("OeYHia")
+		err = v.Set("RuExea")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("qllmQ:a")
+		err = v.Set("TnyDK:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]float64", v.Type())
@@ -7914,17 +7914,17 @@ func TestIntFloat64MapValue(t *testing.T) {
 		v := newIntFloat64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310.2")
+		err = v.Set("710.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("7:10.2")
+		err = v.Set("5:10.2")
 		assert.Nil(t, err)
 		err = v.Set("720.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("6:20.99")
+		err = v.Set("1:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]float64", v.Type())
@@ -7936,11 +7936,11 @@ func TestIntFloat64MapValue(t *testing.T) {
 		v := newIntFloat64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4a")
+		err = v.Set("5a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("7:a")
+		err = v.Set("0:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]float64", v.Type())
@@ -7961,7 +7961,7 @@ func TestInt8Float64MapValue(t *testing.T) {
 		assert.NotNil(t, err)
 		err = v.Set("1:10.2")
 		assert.Nil(t, err)
-		err = v.Set("420.99")
+		err = v.Set("720.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
@@ -7977,11 +7977,11 @@ func TestInt8Float64MapValue(t *testing.T) {
 		v := newInt8Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("1:a")
+		err = v.Set("3:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]float64", v.Type())
@@ -7996,17 +7996,17 @@ func TestInt16Float64MapValue(t *testing.T) {
 		v := newInt16Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("210.2")
+		err = v.Set("510.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("5:10.2")
+		err = v.Set("1:10.2")
 		assert.Nil(t, err)
-		err = v.Set("720.99")
+		err = v.Set("620.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("1:20.99")
+		err = v.Set("7:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]float64", v.Type())
@@ -8018,11 +8018,11 @@ func TestInt16Float64MapValue(t *testing.T) {
 		v := newInt16Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("1:a")
+		err = v.Set("0:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]float64", v.Type())
@@ -8037,11 +8037,11 @@ func TestInt32Float64MapValue(t *testing.T) {
 		v := newInt32Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610.2")
+		err = v.Set("110.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("0:10.2")
+		err = v.Set("2:10.2")
 		assert.Nil(t, err)
 		err = v.Set("220.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
@@ -8059,11 +8059,11 @@ func TestInt32Float64MapValue(t *testing.T) {
 		v := newInt32Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6a")
+		err = v.Set("7a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("0:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]float64", v.Type())
@@ -8078,13 +8078,13 @@ func TestInt64Float64MapValue(t *testing.T) {
 		v := newInt64Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410.2")
+		err = v.Set("510.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("4:10.2")
+		err = v.Set("6:10.2")
 		assert.Nil(t, err)
-		err = v.Set("720.99")
+		err = v.Set("220.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
@@ -8100,11 +8100,11 @@ func TestInt64Float64MapValue(t *testing.T) {
 		v := newInt64Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("3:a")
+		err = v.Set("0:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]float64", v.Type())
@@ -8119,17 +8119,17 @@ func TestUintFloat64MapValue(t *testing.T) {
 		v := newUintFloat64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("210.2")
+		err = v.Set("710.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("1:10.2")
+		err = v.Set("5:10.2")
 		assert.Nil(t, err)
-		err = v.Set("720.99")
+		err = v.Set("520.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("6:20.99")
+		err = v.Set("0:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]float64", v.Type())
@@ -8141,11 +8141,11 @@ func TestUintFloat64MapValue(t *testing.T) {
 		v := newUintFloat64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3a")
+		err = v.Set("2a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("6:a")
+		err = v.Set("4:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]float64", v.Type())
@@ -8164,13 +8164,13 @@ func TestUint8Float64MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("0:10.2")
+		err = v.Set("7:10.2")
 		assert.Nil(t, err)
-		err = v.Set("120.99")
+		err = v.Set("720.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("4:20.99")
+		err = v.Set("2:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]float64", v.Type())
@@ -8182,11 +8182,11 @@ func TestUint8Float64MapValue(t *testing.T) {
 		v := newUint8Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5a")
+		err = v.Set("2a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("0:a")
+		err = v.Set("7:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]float64", v.Type())
@@ -8201,17 +8201,17 @@ func TestUint16Float64MapValue(t *testing.T) {
 		v := newUint16Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710.2")
+		err = v.Set("210.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("0:10.2")
+		err = v.Set("2:10.2")
 		assert.Nil(t, err)
-		err = v.Set("420.99")
+		err = v.Set("120.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("3:20.99")
+		err = v.Set("0:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]float64", v.Type())
@@ -8223,11 +8223,11 @@ func TestUint16Float64MapValue(t *testing.T) {
 		v := newUint16Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0a")
+		err = v.Set("7a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("4:a")
+		err = v.Set("7:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]float64", v.Type())
@@ -8242,17 +8242,17 @@ func TestUint32Float64MapValue(t *testing.T) {
 		v := newUint32Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610.2")
+		err = v.Set("210.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("7:10.2")
+		err = v.Set("1:10.2")
 		assert.Nil(t, err)
-		err = v.Set("020.99")
+		err = v.Set("220.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("3:20.99")
+		err = v.Set("4:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]float64", v.Type())
@@ -8264,11 +8264,11 @@ func TestUint32Float64MapValue(t *testing.T) {
 		v := newUint32Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3a")
+		err = v.Set("6a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("6:a")
+		err = v.Set("1:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]float64", v.Type())
@@ -8283,17 +8283,17 @@ func TestUint64Float64MapValue(t *testing.T) {
 		v := newUint64Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110.2")
+		err = v.Set("410.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("3:10.2")
+		err = v.Set("0:10.2")
 		assert.Nil(t, err)
-		err = v.Set("420.99")
+		err = v.Set("120.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("5:20.99")
+		err = v.Set("3:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]float64", v.Type())
@@ -8305,11 +8305,11 @@ func TestUint64Float64MapValue(t *testing.T) {
 		v := newUint64Float64MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("6:a")
+		err = v.Set("5:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]float64", v.Type())
@@ -8505,13 +8505,13 @@ func TestStringFloat32MapValue(t *testing.T) {
 		v := newStringFloat32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("cVZgO10.2")
+		err = v.Set("wXrlb10.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("iUebv:10.2")
+		err = v.Set("IMxdl:10.2")
 		assert.Nil(t, err)
-		err = v.Set("hNDye20.99")
+		err = v.Set("hTYoj20.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("ybuCc:20.99")
+		err = v.Set("LmOXw:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]float32", v.Type())
@@ -8523,9 +8523,9 @@ func TestStringFloat32MapValue(t *testing.T) {
 		v := newStringFloat32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("zMdbsa")
+		err = v.Set("srEnPa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("uvBAw:a")
+		err = v.Set("vwhRx:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]float32", v.Type())
@@ -8540,17 +8540,17 @@ func TestIntFloat32MapValue(t *testing.T) {
 		v := newIntFloat32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410.2")
+		err = v.Set("010.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("2:10.2")
+		err = v.Set("5:10.2")
 		assert.Nil(t, err)
 		err = v.Set("020.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("3:20.99")
+		err = v.Set("2:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]float32", v.Type())
@@ -8562,11 +8562,11 @@ func TestIntFloat32MapValue(t *testing.T) {
 		v := newIntFloat32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1a")
+		err = v.Set("7a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("1:a")
+		err = v.Set("0:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]float32", v.Type())
@@ -8581,17 +8581,17 @@ func TestInt8Float32MapValue(t *testing.T) {
 		v := newInt8Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310.2")
+		err = v.Set("410.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("7:10.2")
+		err = v.Set("3:10.2")
 		assert.Nil(t, err)
-		err = v.Set("220.99")
+		err = v.Set("620.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("4:20.99")
+		err = v.Set("5:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]float32", v.Type())
@@ -8603,11 +8603,11 @@ func TestInt8Float32MapValue(t *testing.T) {
 		v := newInt8Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2a")
+		err = v.Set("4a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("7:a")
+		err = v.Set("6:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]float32", v.Type())
@@ -8622,17 +8622,17 @@ func TestInt16Float32MapValue(t *testing.T) {
 		v := newInt16Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710.2")
+		err = v.Set("610.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("4:10.2")
+		err = v.Set("7:10.2")
 		assert.Nil(t, err)
 		err = v.Set("320.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("3:20.99")
+		err = v.Set("4:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]float32", v.Type())
@@ -8644,11 +8644,11 @@ func TestInt16Float32MapValue(t *testing.T) {
 		v := newInt16Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0a")
+		err = v.Set("6a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("0:a")
+		err = v.Set("6:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]float32", v.Type())
@@ -8667,13 +8667,13 @@ func TestInt32Float32MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("2:10.2")
+		err = v.Set("7:10.2")
 		assert.Nil(t, err)
-		err = v.Set("320.99")
+		err = v.Set("020.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("4:20.99")
+		err = v.Set("0:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]float32", v.Type())
@@ -8685,11 +8685,11 @@ func TestInt32Float32MapValue(t *testing.T) {
 		v := newInt32Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("4:a")
+		err = v.Set("1:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]float32", v.Type())
@@ -8704,17 +8704,17 @@ func TestInt64Float32MapValue(t *testing.T) {
 		v := newInt64Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610.2")
+		err = v.Set("010.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("5:10.2")
+		err = v.Set("1:10.2")
 		assert.Nil(t, err)
-		err = v.Set("420.99")
+		err = v.Set("320.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("3:20.99")
+		err = v.Set("2:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]float32", v.Type())
@@ -8726,11 +8726,11 @@ func TestInt64Float32MapValue(t *testing.T) {
 		v := newInt64Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2a")
+		err = v.Set("0a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("7:a")
+		err = v.Set("3:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]float32", v.Type())
@@ -8745,17 +8745,17 @@ func TestUintFloat32MapValue(t *testing.T) {
 		v := newUintFloat32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("010.2")
+		err = v.Set("610.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("5:10.2")
+		err = v.Set("0:10.2")
 		assert.Nil(t, err)
-		err = v.Set("120.99")
+		err = v.Set("020.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("6:20.99")
+		err = v.Set("3:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]float32", v.Type())
@@ -8786,17 +8786,17 @@ func TestUint8Float32MapValue(t *testing.T) {
 		v := newUint8Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("210.2")
+		err = v.Set("110.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("3:10.2")
+		err = v.Set("4:10.2")
 		assert.Nil(t, err)
-		err = v.Set("420.99")
+		err = v.Set("520.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("1:20.99")
+		err = v.Set("7:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]float32", v.Type())
@@ -8808,11 +8808,11 @@ func TestUint8Float32MapValue(t *testing.T) {
 		v := newUint8Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7a")
+		err = v.Set("3a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("5:a")
+		err = v.Set("7:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]float32", v.Type())
@@ -8827,11 +8827,11 @@ func TestUint16Float32MapValue(t *testing.T) {
 		v := newUint16Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410.2")
+		err = v.Set("310.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("7:10.2")
+		err = v.Set("5:10.2")
 		assert.Nil(t, err)
 		err = v.Set("320.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
@@ -8849,11 +8849,11 @@ func TestUint16Float32MapValue(t *testing.T) {
 		v := newUint16Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0a")
+		err = v.Set("7a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("0:a")
+		err = v.Set("3:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]float32", v.Type())
@@ -8868,17 +8868,17 @@ func TestUint32Float32MapValue(t *testing.T) {
 		v := newUint32Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410.2")
+		err = v.Set("110.2")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("1:10.2")
+		err = v.Set("3:10.2")
 		assert.Nil(t, err)
-		err = v.Set("620.99")
+		err = v.Set("020.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("1:20.99")
+		err = v.Set("7:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]float32", v.Type())
@@ -8890,11 +8890,11 @@ func TestUint32Float32MapValue(t *testing.T) {
 		v := newUint32Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3a")
+		err = v.Set("2a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("7:a")
+		err = v.Set("5:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]float32", v.Type())
@@ -8913,13 +8913,13 @@ func TestUint64Float32MapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10.2")
 		assert.NotNil(t, err)
-		err = v.Set("7:10.2")
+		err = v.Set("4:10.2")
 		assert.Nil(t, err)
-		err = v.Set("020.99")
+		err = v.Set("720.99")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":20.99")
 		assert.NotNil(t, err)
-		err = v.Set("2:20.99")
+		err = v.Set("3:20.99")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]float32", v.Type())
@@ -8931,11 +8931,11 @@ func TestUint64Float32MapValue(t *testing.T) {
 		v := newUint64Float32MapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5a")
+		err = v.Set("1a")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":a")
 		assert.NotNil(t, err)
-		err = v.Set("0:a")
+		err = v.Set("2:a")
 		assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]float32", v.Type())
@@ -9121,13 +9121,13 @@ func TestStringDurationMapValue(t *testing.T) {
 		v := newStringDurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("dePor10s")
+		err = v.Set("EnGJV10s")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("oyNdT:10s")
+		err = v.Set("hDPTi:10s")
 		assert.Nil(t, err)
-		err = v.Set("EBcbh30m")
+		err = v.Set("HMyyo30m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("jmcXV:30m")
+		err = v.Set("YLaeV:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]time.Duration", v.Type())
@@ -9139,9 +9139,9 @@ func TestStringDurationMapValue(t *testing.T) {
 		v := newStringDurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("InyIN3l")
+		err = v.Set("uuEpn3l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("mnpPy:3l")
+		err = v.Set("AMlnf:3l")
 		assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]time.Duration", v.Type())
@@ -9156,17 +9156,17 @@ func TestIntDurationMapValue(t *testing.T) {
 		v := newIntDurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710s")
+		err = v.Set("310s")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10s")
 		assert.NotNil(t, err)
-		err = v.Set("6:10s")
+		err = v.Set("1:10s")
 		assert.Nil(t, err)
 		err = v.Set("530m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":30m")
 		assert.NotNil(t, err)
-		err = v.Set("2:30m")
+		err = v.Set("3:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]time.Duration", v.Type())
@@ -9178,11 +9178,11 @@ func TestIntDurationMapValue(t *testing.T) {
 		v := newIntDurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("13l")
+		err = v.Set("33l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":3l")
 		assert.NotNil(t, err)
-		err = v.Set("4:3l")
+		err = v.Set("6:3l")
 		assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]time.Duration", v.Type())
@@ -9201,13 +9201,13 @@ func TestInt8DurationMapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10s")
 		assert.NotNil(t, err)
-		err = v.Set("2:10s")
+		err = v.Set("7:10s")
 		assert.Nil(t, err)
-		err = v.Set("330m")
+		err = v.Set("230m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":30m")
 		assert.NotNil(t, err)
-		err = v.Set("5:30m")
+		err = v.Set("3:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]time.Duration", v.Type())
@@ -9219,11 +9219,11 @@ func TestInt8DurationMapValue(t *testing.T) {
 		v := newInt8DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("33l")
+		err = v.Set("73l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":3l")
 		assert.NotNil(t, err)
-		err = v.Set("0:3l")
+		err = v.Set("5:3l")
 		assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]time.Duration", v.Type())
@@ -9238,17 +9238,17 @@ func TestInt16DurationMapValue(t *testing.T) {
 		v := newInt16DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310s")
+		err = v.Set("610s")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10s")
 		assert.NotNil(t, err)
-		err = v.Set("1:10s")
+		err = v.Set("3:10s")
 		assert.Nil(t, err)
 		err = v.Set("330m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":30m")
 		assert.NotNil(t, err)
-		err = v.Set("2:30m")
+		err = v.Set("7:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]time.Duration", v.Type())
@@ -9260,7 +9260,7 @@ func TestInt16DurationMapValue(t *testing.T) {
 		v := newInt16DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("63l")
+		err = v.Set("33l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":3l")
 		assert.NotNil(t, err)
@@ -9279,17 +9279,17 @@ func TestInt32DurationMapValue(t *testing.T) {
 		v := newInt32DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610s")
+		err = v.Set("410s")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10s")
 		assert.NotNil(t, err)
-		err = v.Set("5:10s")
+		err = v.Set("6:10s")
 		assert.Nil(t, err)
-		err = v.Set("230m")
+		err = v.Set("330m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":30m")
 		assert.NotNil(t, err)
-		err = v.Set("7:30m")
+		err = v.Set("6:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]time.Duration", v.Type())
@@ -9301,11 +9301,11 @@ func TestInt32DurationMapValue(t *testing.T) {
 		v := newInt32DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("33l")
+		err = v.Set("73l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":3l")
 		assert.NotNil(t, err)
-		err = v.Set("5:3l")
+		err = v.Set("7:3l")
 		assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]time.Duration", v.Type())
@@ -9320,17 +9320,17 @@ func TestInt64DurationMapValue(t *testing.T) {
 		v := newInt64DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410s")
+		err = v.Set("510s")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10s")
 		assert.NotNil(t, err)
-		err = v.Set("7:10s")
+		err = v.Set("6:10s")
 		assert.Nil(t, err)
 		err = v.Set("430m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":30m")
 		assert.NotNil(t, err)
-		err = v.Set("6:30m")
+		err = v.Set("1:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]time.Duration", v.Type())
@@ -9342,11 +9342,11 @@ func TestInt64DurationMapValue(t *testing.T) {
 		v := newInt64DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("63l")
+		err = v.Set("73l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":3l")
 		assert.NotNil(t, err)
-		err = v.Set("1:3l")
+		err = v.Set("3:3l")
 		assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]time.Duration", v.Type())
@@ -9361,17 +9361,17 @@ func TestUintDurationMapValue(t *testing.T) {
 		v := newUintDurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("110s")
+		err = v.Set("710s")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10s")
 		assert.NotNil(t, err)
 		err = v.Set("0:10s")
 		assert.Nil(t, err)
-		err = v.Set("130m")
+		err = v.Set("230m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":30m")
 		assert.NotNil(t, err)
-		err = v.Set("2:30m")
+		err = v.Set("0:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]time.Duration", v.Type())
@@ -9383,11 +9383,11 @@ func TestUintDurationMapValue(t *testing.T) {
 		v := newUintDurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("33l")
+		err = v.Set("23l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":3l")
 		assert.NotNil(t, err)
-		err = v.Set("5:3l")
+		err = v.Set("7:3l")
 		assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]time.Duration", v.Type())
@@ -9402,17 +9402,17 @@ func TestUint8DurationMapValue(t *testing.T) {
 		v := newUint8DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("310s")
+		err = v.Set("510s")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10s")
 		assert.NotNil(t, err)
-		err = v.Set("5:10s")
+		err = v.Set("1:10s")
 		assert.Nil(t, err)
-		err = v.Set("530m")
+		err = v.Set("630m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":30m")
 		assert.NotNil(t, err)
-		err = v.Set("7:30m")
+		err = v.Set("0:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]time.Duration", v.Type())
@@ -9424,11 +9424,11 @@ func TestUint8DurationMapValue(t *testing.T) {
 		v := newUint8DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("33l")
+		err = v.Set("63l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":3l")
 		assert.NotNil(t, err)
-		err = v.Set("3:3l")
+		err = v.Set("4:3l")
 		assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]time.Duration", v.Type())
@@ -9443,17 +9443,17 @@ func TestUint16DurationMapValue(t *testing.T) {
 		v := newUint16DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("410s")
+		err = v.Set("010s")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10s")
 		assert.NotNil(t, err)
-		err = v.Set("4:10s")
+		err = v.Set("5:10s")
 		assert.Nil(t, err)
 		err = v.Set("030m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":30m")
 		assert.NotNil(t, err)
-		err = v.Set("1:30m")
+		err = v.Set("6:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]time.Duration", v.Type())
@@ -9465,11 +9465,11 @@ func TestUint16DurationMapValue(t *testing.T) {
 		v := newUint16DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("43l")
+		err = v.Set("13l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":3l")
 		assert.NotNil(t, err)
-		err = v.Set("3:3l")
+		err = v.Set("2:3l")
 		assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]time.Duration", v.Type())
@@ -9484,17 +9484,17 @@ func TestUint32DurationMapValue(t *testing.T) {
 		v := newUint32DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("710s")
+		err = v.Set("610s")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10s")
 		assert.NotNil(t, err)
-		err = v.Set("3:10s")
+		err = v.Set("6:10s")
 		assert.Nil(t, err)
-		err = v.Set("130m")
+		err = v.Set("430m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":30m")
 		assert.NotNil(t, err)
-		err = v.Set("1:30m")
+		err = v.Set("6:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]time.Duration", v.Type())
@@ -9506,11 +9506,11 @@ func TestUint32DurationMapValue(t *testing.T) {
 		v := newUint32DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("03l")
+		err = v.Set("53l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":3l")
 		assert.NotNil(t, err)
-		err = v.Set("5:3l")
+		err = v.Set("0:3l")
 		assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]time.Duration", v.Type())
@@ -9525,17 +9525,17 @@ func TestUint64DurationMapValue(t *testing.T) {
 		v := newUint64DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("610s")
+		err = v.Set("710s")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":10s")
 		assert.NotNil(t, err)
-		err = v.Set("2:10s")
+		err = v.Set("0:10s")
 		assert.Nil(t, err)
-		err = v.Set("030m")
+		err = v.Set("630m")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":30m")
 		assert.NotNil(t, err)
-		err = v.Set("7:30m")
+		err = v.Set("2:30m")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]time.Duration", v.Type())
@@ -9547,11 +9547,11 @@ func TestUint64DurationMapValue(t *testing.T) {
 		v := newUint64DurationMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("03l")
+		err = v.Set("53l")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":3l")
 		assert.NotNil(t, err)
-		err = v.Set("5:3l")
+		err = v.Set("7:3l")
 		assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]time.Duration", v.Type())
@@ -9737,13 +9737,13 @@ func TestStringIPMapValue(t *testing.T) {
 		v := newStringIPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("hPVqi127.0.0.1")
+		err = v.Set("ptmQh127.0.0.1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("crRzo:127.0.0.1")
+		err = v.Set("agKCM:127.0.0.1")
 		assert.Nil(t, err)
-		err = v.Set("aEsNw127.0.0.3")
+		err = v.Set("lyuxY127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("peGOe:127.0.0.3")
+		err = v.Set("vapzk:127.0.0.3")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]net.IP", v.Type())
@@ -9755,9 +9755,9 @@ func TestStringIPMapValue(t *testing.T) {
 		v := newStringIPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("reGcf127.0.0.1.3")
+		err = v.Set("yYhXZ127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("bcUTZ:127.0.0.1.3")
+		err = v.Set("LTfLc:127.0.0.1.3")
 		assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]net.IP", v.Type())
@@ -9772,17 +9772,17 @@ func TestIntIPMapValue(t *testing.T) {
 		v := newIntIPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0127.0.0.1")
+		err = v.Set("1127.0.0.1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1")
 		assert.NotNil(t, err)
-		err = v.Set("6:127.0.0.1")
+		err = v.Set("0:127.0.0.1")
 		assert.Nil(t, err)
 		err = v.Set("7127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.3")
 		assert.NotNil(t, err)
-		err = v.Set("7:127.0.0.3")
+		err = v.Set("2:127.0.0.3")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]net.IP", v.Type())
@@ -9794,11 +9794,11 @@ func TestIntIPMapValue(t *testing.T) {
 		v := newIntIPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7127.0.0.1.3")
+		err = v.Set("6127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1.3")
 		assert.NotNil(t, err)
-		err = v.Set("4:127.0.0.1.3")
+		err = v.Set("3:127.0.0.1.3")
 		assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]net.IP", v.Type())
@@ -9813,17 +9813,17 @@ func TestInt8IPMapValue(t *testing.T) {
 		v := newInt8IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1127.0.0.1")
+		err = v.Set("0127.0.0.1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1")
 		assert.NotNil(t, err)
-		err = v.Set("0:127.0.0.1")
+		err = v.Set("6:127.0.0.1")
 		assert.Nil(t, err)
 		err = v.Set("7127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.3")
 		assert.NotNil(t, err)
-		err = v.Set("2:127.0.0.3")
+		err = v.Set("1:127.0.0.3")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]net.IP", v.Type())
@@ -9835,11 +9835,11 @@ func TestInt8IPMapValue(t *testing.T) {
 		v := newInt8IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0127.0.0.1.3")
+		err = v.Set("1127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1.3")
 		assert.NotNil(t, err)
-		err = v.Set("4:127.0.0.1.3")
+		err = v.Set("0:127.0.0.1.3")
 		assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]net.IP", v.Type())
@@ -9854,17 +9854,17 @@ func TestInt16IPMapValue(t *testing.T) {
 		v := newInt16IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2127.0.0.1")
+		err = v.Set("5127.0.0.1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1")
 		assert.NotNil(t, err)
-		err = v.Set("7:127.0.0.1")
+		err = v.Set("4:127.0.0.1")
 		assert.Nil(t, err)
-		err = v.Set("4127.0.0.3")
+		err = v.Set("2127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.3")
 		assert.NotNil(t, err)
-		err = v.Set("3:127.0.0.3")
+		err = v.Set("7:127.0.0.3")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]net.IP", v.Type())
@@ -9876,11 +9876,11 @@ func TestInt16IPMapValue(t *testing.T) {
 		v := newInt16IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4127.0.0.1.3")
+		err = v.Set("5127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1.3")
 		assert.NotNil(t, err)
-		err = v.Set("7:127.0.0.1.3")
+		err = v.Set("3:127.0.0.1.3")
 		assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]net.IP", v.Type())
@@ -9895,13 +9895,13 @@ func TestInt32IPMapValue(t *testing.T) {
 		v := newInt32IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3127.0.0.1")
+		err = v.Set("7127.0.0.1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1")
 		assert.NotNil(t, err)
-		err = v.Set("0:127.0.0.1")
+		err = v.Set("3:127.0.0.1")
 		assert.Nil(t, err)
-		err = v.Set("1127.0.0.3")
+		err = v.Set("3127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.3")
 		assert.NotNil(t, err)
@@ -9917,7 +9917,7 @@ func TestInt32IPMapValue(t *testing.T) {
 		v := newInt32IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6127.0.0.1.3")
+		err = v.Set("1127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1.3")
 		assert.NotNil(t, err)
@@ -9936,17 +9936,17 @@ func TestInt64IPMapValue(t *testing.T) {
 		v := newInt64IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0127.0.0.1")
+		err = v.Set("1127.0.0.1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1")
 		assert.NotNil(t, err)
-		err = v.Set("4:127.0.0.1")
+		err = v.Set("1:127.0.0.1")
 		assert.Nil(t, err)
-		err = v.Set("0127.0.0.3")
+		err = v.Set("4127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.3")
 		assert.NotNil(t, err)
-		err = v.Set("1:127.0.0.3")
+		err = v.Set("4:127.0.0.3")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]net.IP", v.Type())
@@ -9958,7 +9958,7 @@ func TestInt64IPMapValue(t *testing.T) {
 		v := newInt64IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6127.0.0.1.3")
+		err = v.Set("1127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1.3")
 		assert.NotNil(t, err)
@@ -9977,17 +9977,17 @@ func TestUintIPMapValue(t *testing.T) {
 		v := newUintIPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5127.0.0.1")
+		err = v.Set("6127.0.0.1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1")
 		assert.NotNil(t, err)
-		err = v.Set("2:127.0.0.1")
+		err = v.Set("5:127.0.0.1")
 		assert.Nil(t, err)
-		err = v.Set("3127.0.0.3")
+		err = v.Set("1127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.3")
 		assert.NotNil(t, err)
-		err = v.Set("5:127.0.0.3")
+		err = v.Set("6:127.0.0.3")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]net.IP", v.Type())
@@ -9999,11 +9999,11 @@ func TestUintIPMapValue(t *testing.T) {
 		v := newUintIPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2127.0.0.1.3")
+		err = v.Set("5127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1.3")
 		assert.NotNil(t, err)
-		err = v.Set("1:127.0.0.1.3")
+		err = v.Set("0:127.0.0.1.3")
 		assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]net.IP", v.Type())
@@ -10022,13 +10022,13 @@ func TestUint8IPMapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1")
 		assert.NotNil(t, err)
-		err = v.Set("4:127.0.0.1")
+		err = v.Set("0:127.0.0.1")
 		assert.Nil(t, err)
-		err = v.Set("2127.0.0.3")
+		err = v.Set("0127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.3")
 		assert.NotNil(t, err)
-		err = v.Set("6:127.0.0.3")
+		err = v.Set("7:127.0.0.3")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]net.IP", v.Type())
@@ -10040,11 +10040,11 @@ func TestUint8IPMapValue(t *testing.T) {
 		v := newUint8IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0127.0.0.1.3")
+		err = v.Set("5127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1.3")
 		assert.NotNil(t, err)
-		err = v.Set("2:127.0.0.1.3")
+		err = v.Set("3:127.0.0.1.3")
 		assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]net.IP", v.Type())
@@ -10059,17 +10059,17 @@ func TestUint16IPMapValue(t *testing.T) {
 		v := newUint16IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4127.0.0.1")
+		err = v.Set("2127.0.0.1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1")
 		assert.NotNil(t, err)
-		err = v.Set("6:127.0.0.1")
+		err = v.Set("1:127.0.0.1")
 		assert.Nil(t, err)
-		err = v.Set("5127.0.0.3")
+		err = v.Set("1127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.3")
 		assert.NotNil(t, err)
-		err = v.Set("7:127.0.0.3")
+		err = v.Set("3:127.0.0.3")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]net.IP", v.Type())
@@ -10081,11 +10081,11 @@ func TestUint16IPMapValue(t *testing.T) {
 		v := newUint16IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5127.0.0.1.3")
+		err = v.Set("6127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1.3")
 		assert.NotNil(t, err)
-		err = v.Set("5:127.0.0.1.3")
+		err = v.Set("6:127.0.0.1.3")
 		assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]net.IP", v.Type())
@@ -10100,13 +10100,13 @@ func TestUint32IPMapValue(t *testing.T) {
 		v := newUint32IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4127.0.0.1")
+		err = v.Set("2127.0.0.1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1")
 		assert.NotNil(t, err)
-		err = v.Set("3:127.0.0.1")
+		err = v.Set("5:127.0.0.1")
 		assert.Nil(t, err)
-		err = v.Set("7127.0.0.3")
+		err = v.Set("2127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.3")
 		assert.NotNil(t, err)
@@ -10122,11 +10122,11 @@ func TestUint32IPMapValue(t *testing.T) {
 		v := newUint32IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3127.0.0.1.3")
+		err = v.Set("6127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1.3")
 		assert.NotNil(t, err)
-		err = v.Set("2:127.0.0.1.3")
+		err = v.Set("6:127.0.0.1.3")
 		assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]net.IP", v.Type())
@@ -10141,17 +10141,17 @@ func TestUint64IPMapValue(t *testing.T) {
 		v := newUint64IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7127.0.0.1")
+		err = v.Set("0127.0.0.1")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1")
 		assert.NotNil(t, err)
-		err = v.Set("2:127.0.0.1")
+		err = v.Set("4:127.0.0.1")
 		assert.Nil(t, err)
 		err = v.Set("7127.0.0.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.3")
 		assert.NotNil(t, err)
-		err = v.Set("7:127.0.0.3")
+		err = v.Set("1:127.0.0.3")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]net.IP", v.Type())
@@ -10163,11 +10163,11 @@ func TestUint64IPMapValue(t *testing.T) {
 		v := newUint64IPMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7127.0.0.1.3")
+		err = v.Set("6127.0.0.1.3")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":127.0.0.1.3")
 		assert.NotNil(t, err)
-		err = v.Set("1:127.0.0.1.3")
+		err = v.Set("5:127.0.0.1.3")
 		assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]net.IP", v.Type())
@@ -10373,13 +10373,13 @@ func TestStringHexBytesMapValue(t *testing.T) {
 		v := newStringHexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("WjNXoff")
+		err = v.Set("UWQpwff")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("xOWtq:ff")
+		err = v.Set("KViVe:ff")
 		assert.Nil(t, err)
-		err = v.Set("MBoKnaa")
+		err = v.Set("PoqYuaa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("mQySg:aa")
+		err = v.Set("bqHHM:aa")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]HexBytes", v.Type())
@@ -10391,9 +10391,9 @@ func TestStringHexBytesMapValue(t *testing.T) {
 		v := newStringHexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("cKukagg")
+		err = v.Set("CQsMtgg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("PXZLX:gg")
+		err = v.Set("wdJPZ:gg")
 		assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]HexBytes", v.Type())
@@ -10408,17 +10408,17 @@ func TestIntHexBytesMapValue(t *testing.T) {
 		v := newIntHexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1ff")
+		err = v.Set("4ff")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":ff")
 		assert.NotNil(t, err)
-		err = v.Set("0:ff")
+		err = v.Set("2:ff")
 		assert.Nil(t, err)
-		err = v.Set("6aa")
+		err = v.Set("2aa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":aa")
 		assert.NotNil(t, err)
-		err = v.Set("7:aa")
+		err = v.Set("1:aa")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]HexBytes", v.Type())
@@ -10430,11 +10430,11 @@ func TestIntHexBytesMapValue(t *testing.T) {
 		v := newIntHexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4gg")
+		err = v.Set("7gg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":gg")
 		assert.NotNil(t, err)
-		err = v.Set("1:gg")
+		err = v.Set("3:gg")
 		assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]HexBytes", v.Type())
@@ -10449,17 +10449,17 @@ func TestInt8HexBytesMapValue(t *testing.T) {
 		v := newInt8HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1ff")
+		err = v.Set("3ff")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":ff")
 		assert.NotNil(t, err)
-		err = v.Set("1:ff")
+		err = v.Set("2:ff")
 		assert.Nil(t, err)
-		err = v.Set("2aa")
+		err = v.Set("5aa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":aa")
 		assert.NotNil(t, err)
-		err = v.Set("6:aa")
+		err = v.Set("0:aa")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]HexBytes", v.Type())
@@ -10471,11 +10471,11 @@ func TestInt8HexBytesMapValue(t *testing.T) {
 		v := newInt8HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1gg")
+		err = v.Set("0gg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":gg")
 		assert.NotNil(t, err)
-		err = v.Set("4:gg")
+		err = v.Set("6:gg")
 		assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]HexBytes", v.Type())
@@ -10490,13 +10490,13 @@ func TestInt16HexBytesMapValue(t *testing.T) {
 		v := newInt16HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0ff")
+		err = v.Set("6ff")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":ff")
 		assert.NotNil(t, err)
-		err = v.Set("2:ff")
+		err = v.Set("0:ff")
 		assert.Nil(t, err)
-		err = v.Set("3aa")
+		err = v.Set("4aa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":aa")
 		assert.NotNil(t, err)
@@ -10512,7 +10512,7 @@ func TestInt16HexBytesMapValue(t *testing.T) {
 		v := newInt16HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7gg")
+		err = v.Set("4gg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":gg")
 		assert.NotNil(t, err)
@@ -10531,17 +10531,17 @@ func TestInt32HexBytesMapValue(t *testing.T) {
 		v := newInt32HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7ff")
+		err = v.Set("3ff")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":ff")
 		assert.NotNil(t, err)
-		err = v.Set("5:ff")
+		err = v.Set("1:ff")
 		assert.Nil(t, err)
-		err = v.Set("2aa")
+		err = v.Set("7aa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":aa")
 		assert.NotNil(t, err)
-		err = v.Set("1:aa")
+		err = v.Set("2:aa")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]HexBytes", v.Type())
@@ -10553,11 +10553,11 @@ func TestInt32HexBytesMapValue(t *testing.T) {
 		v := newInt32HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7gg")
+		err = v.Set("0gg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":gg")
 		assert.NotNil(t, err)
-		err = v.Set("6:gg")
+		err = v.Set("3:gg")
 		assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]HexBytes", v.Type())
@@ -10576,13 +10576,13 @@ func TestInt64HexBytesMapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":ff")
 		assert.NotNil(t, err)
-		err = v.Set("6:ff")
+		err = v.Set("0:ff")
 		assert.Nil(t, err)
 		err = v.Set("4aa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":aa")
 		assert.NotNil(t, err)
-		err = v.Set("4:aa")
+		err = v.Set("6:aa")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]HexBytes", v.Type())
@@ -10594,11 +10594,11 @@ func TestInt64HexBytesMapValue(t *testing.T) {
 		v := newInt64HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2gg")
+		err = v.Set("0gg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":gg")
 		assert.NotNil(t, err)
-		err = v.Set("3:gg")
+		err = v.Set("6:gg")
 		assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]HexBytes", v.Type())
@@ -10613,13 +10613,13 @@ func TestUintHexBytesMapValue(t *testing.T) {
 		v := newUintHexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7ff")
+		err = v.Set("4ff")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":ff")
 		assert.NotNil(t, err)
 		err = v.Set("6:ff")
 		assert.Nil(t, err)
-		err = v.Set("0aa")
+		err = v.Set("1aa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":aa")
 		assert.NotNil(t, err)
@@ -10635,11 +10635,11 @@ func TestUintHexBytesMapValue(t *testing.T) {
 		v := newUintHexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3gg")
+		err = v.Set("7gg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":gg")
 		assert.NotNil(t, err)
-		err = v.Set("5:gg")
+		err = v.Set("1:gg")
 		assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]HexBytes", v.Type())
@@ -10654,17 +10654,17 @@ func TestUint8HexBytesMapValue(t *testing.T) {
 		v := newUint8HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1ff")
+		err = v.Set("7ff")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":ff")
 		assert.NotNil(t, err)
-		err = v.Set("3:ff")
+		err = v.Set("4:ff")
 		assert.Nil(t, err)
-		err = v.Set("7aa")
+		err = v.Set("5aa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":aa")
 		assert.NotNil(t, err)
-		err = v.Set("7:aa")
+		err = v.Set("4:aa")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]HexBytes", v.Type())
@@ -10676,11 +10676,11 @@ func TestUint8HexBytesMapValue(t *testing.T) {
 		v := newUint8HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6gg")
+		err = v.Set("7gg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":gg")
 		assert.NotNil(t, err)
-		err = v.Set("7:gg")
+		err = v.Set("2:gg")
 		assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]HexBytes", v.Type())
@@ -10695,17 +10695,17 @@ func TestUint16HexBytesMapValue(t *testing.T) {
 		v := newUint16HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0ff")
+		err = v.Set("2ff")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":ff")
 		assert.NotNil(t, err)
-		err = v.Set("7:ff")
+		err = v.Set("6:ff")
 		assert.Nil(t, err)
-		err = v.Set("3aa")
+		err = v.Set("0aa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":aa")
 		assert.NotNil(t, err)
-		err = v.Set("0:aa")
+		err = v.Set("2:aa")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]HexBytes", v.Type())
@@ -10717,11 +10717,11 @@ func TestUint16HexBytesMapValue(t *testing.T) {
 		v := newUint16HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4gg")
+		err = v.Set("2gg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":gg")
 		assert.NotNil(t, err)
-		err = v.Set("0:gg")
+		err = v.Set("1:gg")
 		assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]HexBytes", v.Type())
@@ -10736,17 +10736,17 @@ func TestUint32HexBytesMapValue(t *testing.T) {
 		v := newUint32HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3ff")
+		err = v.Set("2ff")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":ff")
 		assert.NotNil(t, err)
-		err = v.Set("2:ff")
+		err = v.Set("1:ff")
 		assert.Nil(t, err)
-		err = v.Set("3aa")
+		err = v.Set("6aa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":aa")
 		assert.NotNil(t, err)
-		err = v.Set("3:aa")
+		err = v.Set("6:aa")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]HexBytes", v.Type())
@@ -10758,11 +10758,11 @@ func TestUint32HexBytesMapValue(t *testing.T) {
 		v := newUint32HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6gg")
+		err = v.Set("3gg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":gg")
 		assert.NotNil(t, err)
-		err = v.Set("2:gg")
+		err = v.Set("4:gg")
 		assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]HexBytes", v.Type())
@@ -10777,17 +10777,17 @@ func TestUint64HexBytesMapValue(t *testing.T) {
 		v := newUint64HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3ff")
+		err = v.Set("2ff")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":ff")
 		assert.NotNil(t, err)
-		err = v.Set("1:ff")
+		err = v.Set("6:ff")
 		assert.Nil(t, err)
-		err = v.Set("6aa")
+		err = v.Set("4aa")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":aa")
 		assert.NotNil(t, err)
-		err = v.Set("3:aa")
+		err = v.Set("2:aa")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]HexBytes", v.Type())
@@ -10799,7 +10799,7 @@ func TestUint64HexBytesMapValue(t *testing.T) {
 		v := newUint64HexBytesMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1gg")
+		err = v.Set("6gg")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":gg")
 		assert.NotNil(t, err)
@@ -10989,13 +10989,13 @@ func TestStringRegexpMapValue(t *testing.T) {
 		v := newStringRegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("UiAIbabc.*")
+		err = v.Set("vTUctabc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("wLRMC:abc.*")
+		err = v.Set("SyjSF:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("HokCexyz.*")
+		err = v.Set("MHwDCxyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("AktfY:xyz.*")
+		err = v.Set("JOyAs:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]*regexp.Regexp", v.Type())
@@ -11007,9 +11007,9 @@ func TestStringRegexpMapValue(t *testing.T) {
 		v := newStringRegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("ezNXi[abc")
+		err = v.Set("wVJjb[abc")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("jFqCQ:[abc")
+		err = v.Set("UVukK:[abc")
 		assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]*regexp.Regexp", v.Type())
@@ -11024,17 +11024,17 @@ func TestIntRegexpMapValue(t *testing.T) {
 		v := newIntRegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3abc.*")
+		err = v.Set("4abc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":abc.*")
 		assert.NotNil(t, err)
-		err = v.Set("6:abc.*")
+		err = v.Set("7:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("0xyz.*")
+		err = v.Set("2xyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":xyz.*")
 		assert.NotNil(t, err)
-		err = v.Set("2:xyz.*")
+		err = v.Set("1:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]*regexp.Regexp", v.Type())
@@ -11046,11 +11046,11 @@ func TestIntRegexpMapValue(t *testing.T) {
 		v := newIntRegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0[abc")
+		err = v.Set("3[abc")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":[abc")
 		assert.NotNil(t, err)
-		err = v.Set("6:[abc")
+		err = v.Set("3:[abc")
 		assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]*regexp.Regexp", v.Type())
@@ -11065,17 +11065,17 @@ func TestInt8RegexpMapValue(t *testing.T) {
 		v := newInt8RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("7abc.*")
+		err = v.Set("4abc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":abc.*")
 		assert.NotNil(t, err)
-		err = v.Set("1:abc.*")
+		err = v.Set("4:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("6xyz.*")
+		err = v.Set("7xyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":xyz.*")
 		assert.NotNil(t, err)
-		err = v.Set("0:xyz.*")
+		err = v.Set("4:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]*regexp.Regexp", v.Type())
@@ -11087,11 +11087,11 @@ func TestInt8RegexpMapValue(t *testing.T) {
 		v := newInt8RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("3[abc")
+		err = v.Set("1[abc")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":[abc")
 		assert.NotNil(t, err)
-		err = v.Set("2:[abc")
+		err = v.Set("6:[abc")
 		assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]*regexp.Regexp", v.Type())
@@ -11106,17 +11106,17 @@ func TestInt16RegexpMapValue(t *testing.T) {
 		v := newInt16RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2abc.*")
+		err = v.Set("7abc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":abc.*")
 		assert.NotNil(t, err)
-		err = v.Set("4:abc.*")
+		err = v.Set("5:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("4xyz.*")
+		err = v.Set("3xyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":xyz.*")
 		assert.NotNil(t, err)
-		err = v.Set("3:xyz.*")
+		err = v.Set("7:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]*regexp.Regexp", v.Type())
@@ -11128,11 +11128,11 @@ func TestInt16RegexpMapValue(t *testing.T) {
 		v := newInt16RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0[abc")
+		err = v.Set("5[abc")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":[abc")
 		assert.NotNil(t, err)
-		err = v.Set("4:[abc")
+		err = v.Set("2:[abc")
 		assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]*regexp.Regexp", v.Type())
@@ -11147,17 +11147,17 @@ func TestInt32RegexpMapValue(t *testing.T) {
 		v := newInt32RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1abc.*")
+		err = v.Set("0abc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":abc.*")
 		assert.NotNil(t, err)
-		err = v.Set("7:abc.*")
+		err = v.Set("5:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("6xyz.*")
+		err = v.Set("1xyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":xyz.*")
 		assert.NotNil(t, err)
-		err = v.Set("5:xyz.*")
+		err = v.Set("7:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]*regexp.Regexp", v.Type())
@@ -11169,11 +11169,11 @@ func TestInt32RegexpMapValue(t *testing.T) {
 		v := newInt32RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6[abc")
+		err = v.Set("4[abc")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":[abc")
 		assert.NotNil(t, err)
-		err = v.Set("5:[abc")
+		err = v.Set("2:[abc")
 		assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]*regexp.Regexp", v.Type())
@@ -11188,17 +11188,17 @@ func TestInt64RegexpMapValue(t *testing.T) {
 		v := newInt64RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5abc.*")
+		err = v.Set("2abc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":abc.*")
 		assert.NotNil(t, err)
-		err = v.Set("4:abc.*")
+		err = v.Set("0:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("2xyz.*")
+		err = v.Set("5xyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":xyz.*")
 		assert.NotNil(t, err)
-		err = v.Set("1:xyz.*")
+		err = v.Set("6:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]*regexp.Regexp", v.Type())
@@ -11210,11 +11210,11 @@ func TestInt64RegexpMapValue(t *testing.T) {
 		v := newInt64RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1[abc")
+		err = v.Set("2[abc")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":[abc")
 		assert.NotNil(t, err)
-		err = v.Set("0:[abc")
+		err = v.Set("6:[abc")
 		assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int64]*regexp.Regexp", v.Type())
@@ -11229,17 +11229,17 @@ func TestUintRegexpMapValue(t *testing.T) {
 		v := newUintRegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("6abc.*")
+		err = v.Set("2abc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":abc.*")
 		assert.NotNil(t, err)
 		err = v.Set("3:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("7xyz.*")
+		err = v.Set("2xyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":xyz.*")
 		assert.NotNil(t, err)
-		err = v.Set("1:xyz.*")
+		err = v.Set("6:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]*regexp.Regexp", v.Type())
@@ -11270,17 +11270,17 @@ func TestUint8RegexpMapValue(t *testing.T) {
 		v := newUint8RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("4abc.*")
+		err = v.Set("2abc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":abc.*")
 		assert.NotNil(t, err)
-		err = v.Set("2:abc.*")
+		err = v.Set("4:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("0xyz.*")
+		err = v.Set("5xyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":xyz.*")
 		assert.NotNil(t, err)
-		err = v.Set("6:xyz.*")
+		err = v.Set("1:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]*regexp.Regexp", v.Type())
@@ -11292,7 +11292,7 @@ func TestUint8RegexpMapValue(t *testing.T) {
 		v := newUint8RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2[abc")
+		err = v.Set("5[abc")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":[abc")
 		assert.NotNil(t, err)
@@ -11311,17 +11311,17 @@ func TestUint16RegexpMapValue(t *testing.T) {
 		v := newUint16RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1abc.*")
+		err = v.Set("6abc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":abc.*")
 		assert.NotNil(t, err)
-		err = v.Set("4:abc.*")
+		err = v.Set("5:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("6xyz.*")
+		err = v.Set("0xyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":xyz.*")
 		assert.NotNil(t, err)
-		err = v.Set("4:xyz.*")
+		err = v.Set("6:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]*regexp.Regexp", v.Type())
@@ -11333,11 +11333,11 @@ func TestUint16RegexpMapValue(t *testing.T) {
 		v := newUint16RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("2[abc")
+		err = v.Set("0[abc")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":[abc")
 		assert.NotNil(t, err)
-		err = v.Set("4:[abc")
+		err = v.Set("7:[abc")
 		assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]*regexp.Regexp", v.Type())
@@ -11352,17 +11352,17 @@ func TestUint32RegexpMapValue(t *testing.T) {
 		v := newUint32RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1abc.*")
+		err = v.Set("5abc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":abc.*")
 		assert.NotNil(t, err)
-		err = v.Set("4:abc.*")
+		err = v.Set("5:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("5xyz.*")
+		err = v.Set("4xyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":xyz.*")
 		assert.NotNil(t, err)
-		err = v.Set("4:xyz.*")
+		err = v.Set("1:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]*regexp.Regexp", v.Type())
@@ -11374,11 +11374,11 @@ func TestUint32RegexpMapValue(t *testing.T) {
 		v := newUint32RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("0[abc")
+		err = v.Set("2[abc")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":[abc")
 		assert.NotNil(t, err)
-		err = v.Set("3:[abc")
+		err = v.Set("7:[abc")
 		assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]*regexp.Regexp", v.Type())
@@ -11393,17 +11393,17 @@ func TestUint64RegexpMapValue(t *testing.T) {
 		v := newUint64RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("5abc.*")
+		err = v.Set("0abc.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":abc.*")
 		assert.NotNil(t, err)
-		err = v.Set("6:abc.*")
+		err = v.Set("3:abc.*")
 		assert.Nil(t, err)
-		err = v.Set("4xyz.*")
+		err = v.Set("0xyz.*")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":xyz.*")
 		assert.NotNil(t, err)
-		err = v.Set("3:xyz.*")
+		err = v.Set("5:xyz.*")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]*regexp.Regexp", v.Type())
@@ -11415,11 +11415,11 @@ func TestUint64RegexpMapValue(t *testing.T) {
 		v := newUint64RegexpMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("1[abc")
+		err = v.Set("7[abc")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":[abc")
 		assert.NotNil(t, err)
-		err = v.Set("5:[abc")
+		err = v.Set("4:[abc")
 		assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint64]*regexp.Regexp", v.Type())
@@ -11737,13 +11737,13 @@ func TestStringIPNetMapValue(t *testing.T) {
 		v := newStringIPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("FMUiB0.0.0.0/0")
+		err = v.Set("tezIO0.0.0.0/0")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("URLpf:0.0.0.0/0")
+		err = v.Set("ZMfFT:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("GDCxB255.255.255.255/19")
+		err = v.Set("cfBXK255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("AjRnv:255.255.255.255/19")
+		err = v.Set("cYNEA:255.255.255.255/19")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]net.IPNet", v.Type())
@@ -11755,9 +11755,9 @@ func TestStringIPNetMapValue(t *testing.T) {
 		v := newStringIPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("jtsGD0.0.0.256/16")
+		err = v.Set("aFRBj0.0.0.256/16")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
-		err = v.Set("UbvdA:0.0.0.256/16")
+		err = v.Set("XuYFj:0.0.0.256/16")
 		assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[string]net.IPNet", v.Type())
@@ -11772,17 +11772,17 @@ func TestIntIPNetMapValue(t *testing.T) {
 		v := newIntIPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("60.0.0.0/0")
+		err = v.Set("20.0.0.0/0")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.0/0")
 		assert.NotNil(t, err)
-		err = v.Set("6:0.0.0.0/0")
+		err = v.Set("4:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("3255.255.255.255/19")
+		err = v.Set("4255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":255.255.255.255/19")
 		assert.NotNil(t, err)
-		err = v.Set("5:255.255.255.255/19")
+		err = v.Set("7:255.255.255.255/19")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]net.IPNet", v.Type())
@@ -11794,11 +11794,11 @@ func TestIntIPNetMapValue(t *testing.T) {
 		v := newIntIPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("30.0.0.256/16")
+		err = v.Set("60.0.0.256/16")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.256/16")
 		assert.NotNil(t, err)
-		err = v.Set("3:0.0.0.256/16")
+		err = v.Set("5:0.0.0.256/16")
 		assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int]net.IPNet", v.Type())
@@ -11813,17 +11813,17 @@ func TestInt8IPNetMapValue(t *testing.T) {
 		v := newInt8IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("10.0.0.0/0")
+		err = v.Set("00.0.0.0/0")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.0/0")
 		assert.NotNil(t, err)
-		err = v.Set("1:0.0.0.0/0")
+		err = v.Set("3:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("1255.255.255.255/19")
+		err = v.Set("4255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":255.255.255.255/19")
 		assert.NotNil(t, err)
-		err = v.Set("4:255.255.255.255/19")
+		err = v.Set("6:255.255.255.255/19")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]net.IPNet", v.Type())
@@ -11835,11 +11835,11 @@ func TestInt8IPNetMapValue(t *testing.T) {
 		v := newInt8IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("30.0.0.256/16")
+		err = v.Set("20.0.0.256/16")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.256/16")
 		assert.NotNil(t, err)
-		err = v.Set("3:0.0.0.256/16")
+		err = v.Set("2:0.0.0.256/16")
 		assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int8]net.IPNet", v.Type())
@@ -11858,13 +11858,13 @@ func TestInt16IPNetMapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.0/0")
 		assert.NotNil(t, err)
-		err = v.Set("6:0.0.0.0/0")
+		err = v.Set("3:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("1255.255.255.255/19")
+		err = v.Set("2255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":255.255.255.255/19")
 		assert.NotNil(t, err)
-		err = v.Set("0:255.255.255.255/19")
+		err = v.Set("5:255.255.255.255/19")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]net.IPNet", v.Type())
@@ -11876,11 +11876,11 @@ func TestInt16IPNetMapValue(t *testing.T) {
 		v := newInt16IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("50.0.0.256/16")
+		err = v.Set("40.0.0.256/16")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.256/16")
 		assert.NotNil(t, err)
-		err = v.Set("7:0.0.0.256/16")
+		err = v.Set("1:0.0.0.256/16")
 		assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int16]net.IPNet", v.Type())
@@ -11899,13 +11899,13 @@ func TestInt32IPNetMapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.0/0")
 		assert.NotNil(t, err)
-		err = v.Set("2:0.0.0.0/0")
+		err = v.Set("1:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("2255.255.255.255/19")
+		err = v.Set("5255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":255.255.255.255/19")
 		assert.NotNil(t, err)
-		err = v.Set("0:255.255.255.255/19")
+		err = v.Set("4:255.255.255.255/19")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]net.IPNet", v.Type())
@@ -11917,11 +11917,11 @@ func TestInt32IPNetMapValue(t *testing.T) {
 		v := newInt32IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("10.0.0.256/16")
+		err = v.Set("50.0.0.256/16")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.256/16")
 		assert.NotNil(t, err)
-		err = v.Set("2:0.0.0.256/16")
+		err = v.Set("3:0.0.0.256/16")
 		assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[int32]net.IPNet", v.Type())
@@ -11936,13 +11936,13 @@ func TestInt64IPNetMapValue(t *testing.T) {
 		v := newInt64IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("10.0.0.0/0")
+		err = v.Set("50.0.0.0/0")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.0/0")
 		assert.NotNil(t, err)
-		err = v.Set("6:0.0.0.0/0")
+		err = v.Set("7:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("3255.255.255.255/19")
+		err = v.Set("1255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":255.255.255.255/19")
 		assert.NotNil(t, err)
@@ -11958,7 +11958,7 @@ func TestInt64IPNetMapValue(t *testing.T) {
 		v := newInt64IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("70.0.0.256/16")
+		err = v.Set("40.0.0.256/16")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.256/16")
 		assert.NotNil(t, err)
@@ -11977,13 +11977,13 @@ func TestUintIPNetMapValue(t *testing.T) {
 		v := newUintIPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("50.0.0.0/0")
+		err = v.Set("30.0.0.0/0")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.0/0")
 		assert.NotNil(t, err)
-		err = v.Set("0:0.0.0.0/0")
+		err = v.Set("5:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("4255.255.255.255/19")
+		err = v.Set("5255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":255.255.255.255/19")
 		assert.NotNil(t, err)
@@ -11999,11 +11999,11 @@ func TestUintIPNetMapValue(t *testing.T) {
 		v := newUintIPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("10.0.0.256/16")
+		err = v.Set("50.0.0.256/16")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.256/16")
 		assert.NotNil(t, err)
-		err = v.Set("4:0.0.0.256/16")
+		err = v.Set("1:0.0.0.256/16")
 		assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint]net.IPNet", v.Type())
@@ -12018,13 +12018,13 @@ func TestUint8IPNetMapValue(t *testing.T) {
 		v := newUint8IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("00.0.0.0/0")
+		err = v.Set("70.0.0.0/0")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.0/0")
 		assert.NotNil(t, err)
-		err = v.Set("7:0.0.0.0/0")
+		err = v.Set("6:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("3255.255.255.255/19")
+		err = v.Set("2255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":255.255.255.255/19")
 		assert.NotNil(t, err)
@@ -12040,11 +12040,11 @@ func TestUint8IPNetMapValue(t *testing.T) {
 		v := newUint8IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("50.0.0.256/16")
+		err = v.Set("40.0.0.256/16")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.256/16")
 		assert.NotNil(t, err)
-		err = v.Set("1:0.0.0.256/16")
+		err = v.Set("0:0.0.0.256/16")
 		assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint8]net.IPNet", v.Type())
@@ -12059,17 +12059,17 @@ func TestUint16IPNetMapValue(t *testing.T) {
 		v := newUint16IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("10.0.0.0/0")
+		err = v.Set("60.0.0.0/0")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.0/0")
 		assert.NotNil(t, err)
-		err = v.Set("2:0.0.0.0/0")
+		err = v.Set("5:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("0255.255.255.255/19")
+		err = v.Set("4255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":255.255.255.255/19")
 		assert.NotNil(t, err)
-		err = v.Set("2:255.255.255.255/19")
+		err = v.Set("3:255.255.255.255/19")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]net.IPNet", v.Type())
@@ -12085,7 +12085,7 @@ func TestUint16IPNetMapValue(t *testing.T) {
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.256/16")
 		assert.NotNil(t, err)
-		err = v.Set("4:0.0.0.256/16")
+		err = v.Set("6:0.0.0.256/16")
 		assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint16]net.IPNet", v.Type())
@@ -12100,17 +12100,17 @@ func TestUint32IPNetMapValue(t *testing.T) {
 		v := newUint32IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("20.0.0.0/0")
+		err = v.Set("70.0.0.0/0")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.0/0")
 		assert.NotNil(t, err)
-		err = v.Set("2:0.0.0.0/0")
+		err = v.Set("3:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("1255.255.255.255/19")
+		err = v.Set("5255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":255.255.255.255/19")
 		assert.NotNil(t, err)
-		err = v.Set("3:255.255.255.255/19")
+		err = v.Set("7:255.255.255.255/19")
 		assert.Nil(t, err)
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]net.IPNet", v.Type())
@@ -12122,11 +12122,11 @@ func TestUint32IPNetMapValue(t *testing.T) {
 		v := newUint32IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("20.0.0.256/16")
+		err = v.Set("10.0.0.256/16")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.256/16")
 		assert.NotNil(t, err)
-		err = v.Set("2:0.0.0.256/16")
+		err = v.Set("5:0.0.0.256/16")
 		assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16")
 		assert.Equal(t, a, v.Get())
 		assert.Equal(t, "map[uint32]net.IPNet", v.Type())
@@ -12141,13 +12141,13 @@ func TestUint64IPNetMapValue(t *testing.T) {
 		v := newUint64IPNetMapValue(&a)
 		assert.Equal(t, parseGeneratedMap(&a), v)
 		assert.True(t, v.IsCumulative())
-		err = v.Set("50.0.0.0/0")
+		err = v.Set("40.0.0.0/0")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":0.0.0.0/0")
 		assert.NotNil(t, err)
-		err = v.Set("2:0.0.0.0/0")
+		err = v.Set("3:0.0.0.0/0")
 		assert.Nil(t, err)
-		err = v.Set("4255.255.255.255/19")
+		err = v.Set("2255.255.255.255/19")
 		assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1")
 		err = v.Set(":255.255.255.255/19")
 		assert.NotNil(t, err)