diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index d595284ef3c..45b29c8c6ed 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -793,10 +793,6 @@
 			"ImportPath": "github.com/clusterhq/flocker-go",
 			"Rev": "2b8b7259d3139c96c4a6871031355808ab3fd3b3"
 		},
-		{
-			"ImportPath": "github.com/cockroachdb/cmux",
-			"Rev": "112f0506e7743d64a6eb8fedbcff13d9979bbf92"
-		},
 		{
 			"ImportPath": "github.com/codedellemc/goscaleio",
 			"Rev": "20e2ce2cf8852dc78bd42b76698dcd8dcd77b7b1"
@@ -896,368 +892,368 @@
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/alarm",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/auth",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/auth/authpb",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/client",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3/concurrency",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3/namespace",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3/naming",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/compactor",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/discovery",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/embed",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/error",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/etcdhttp",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v2http",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v2http/httptypes",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
+		},
+		{
+			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v2v3",
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3client",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3election",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/gw",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3lock",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/gw",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3rpc",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/auth",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/etcdserverpb",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/etcdserverpb/gw",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/membership",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/stats",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/integration",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/lease",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/lease/leasehttp",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/lease/leasepb",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc/backend",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc/mvccpb",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/adt",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/contention",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/cors",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/cpuutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/crc",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/debugutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/fileutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/httputil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/idutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/ioutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/logutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
-		},
-		{
-			"ImportPath": "github.com/coreos/etcd/pkg/monotime",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/netutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/pathutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/pbutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/runtime",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/schedule",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/srv",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/testutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/tlsutil",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/transport",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/types",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/wait",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/proxy/grpcproxy",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/proxy/grpcproxy/adapter",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/proxy/grpcproxy/cache",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/raft",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/raft/raftpb",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/rafthttp",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/snap",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/snap/snappb",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/store",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/version",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/wal",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/wal/walpb",
-			"Comment": "v3.2.24",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Comment": "v3.3.9",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc",
@@ -1619,133 +1615,133 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/gogoproto",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/compare",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/defaultcheck",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/description",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/embedcheck",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/enumstringer",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/equal",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/face",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/gostring",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/marshalto",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/oneofcheck",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/populate",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/size",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/stringer",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/testgen",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/union",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/unmarshal",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/descriptor",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/generator",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/grpc",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/plugin",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/types",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/vanity",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/vanity/command",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Comment": "v0.5",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
@@ -1769,11 +1765,6 @@
 			"Comment": "v1.1.0",
 			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
 		},
-		{
-			"ImportPath": "github.com/golang/protobuf/protoc-gen-go/descriptor",
-			"Comment": "v1.1.0",
-			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
-		},
 		{
 			"ImportPath": "github.com/golang/protobuf/ptypes",
 			"Comment": "v1.1.0",
@@ -2176,7 +2167,8 @@
 		},
 		{
 			"ImportPath": "github.com/gorilla/websocket",
-			"Rev": "6eb6ad425a89d9da7a5549bc6da8f79ba5c17844"
+			"Comment": "v1.2.0-9-g4201258",
+			"Rev": "4201258b820c74ac8e6922fc9e6b52f71fe46f8d"
 		},
 		{
 			"ImportPath": "github.com/gregjones/httpcache",
@@ -2969,6 +2961,11 @@
 			"Comment": "v1.0.3-11-g89742ae",
 			"Rev": "89742aefa4b206dcf400792f3bd35b542998eb3b"
 		},
+		{
+			"ImportPath": "github.com/soheilhy/cmux",
+			"Comment": "v0.1.3",
+			"Rev": "bb79a83465015a27a175925ebd155e660f55e9f1"
+		},
 		{
 			"ImportPath": "github.com/spf13/afero",
 			"Rev": "b28a7effac979219c2a2ed6205a4d70e4b1bcd02"
@@ -3051,6 +3048,10 @@
 			"ImportPath": "github.com/syndtr/gocapability/capability",
 			"Rev": "e7cb7fa329f456b3855136a2642b197bad7366ba"
 		},
+		{
+			"ImportPath": "github.com/tmc/grpc-websocket-proxy/wsproxy",
+			"Rev": "89b8d40f7ca833297db804fcb3be53a76d01c238"
+		},
 		{
 			"ImportPath": "github.com/tools/godep",
 			"Comment": "v80",
@@ -3058,7 +3059,7 @@
 		},
 		{
 			"ImportPath": "github.com/ugorji/go/codec",
-			"Rev": "ded73eae5db7e7a0ef6f55aace87a2873c5d2b74"
+			"Rev": "bdcc60b419d136a85cdf2e7cbcac34b3f1cd6e57"
 		},
 		{
 			"ImportPath": "github.com/vishvananda/netlink",
@@ -3654,10 +3655,6 @@
 			"ImportPath": "google.golang.org/api/tpu/v1",
 			"Rev": "3639d6d93f377f39a1de765fa4ef37b3c7ca8bd9"
 		},
-		{
-			"ImportPath": "google.golang.org/genproto/googleapis/api/annotations",
-			"Rev": "09f6ed296fc66555a25fe4ce95173148778dfa85"
-		},
 		{
 			"ImportPath": "google.golang.org/genproto/googleapis/rpc/status",
 			"Rev": "09f6ed296fc66555a25fe4ce95173148778dfa85"
@@ -3697,6 +3694,11 @@
 			"Comment": "v1.7.5",
 			"Rev": "5b3c4e850e90a4cf6a20ebd46c8b32a0a3afcb9e"
 		},
+		{
+			"ImportPath": "google.golang.org/grpc/health",
+			"Comment": "v1.7.5",
+			"Rev": "5b3c4e850e90a4cf6a20ebd46c8b32a0a3afcb9e"
+		},
 		{
 			"ImportPath": "google.golang.org/grpc/health/grpc_health_v1",
 			"Comment": "v1.7.5",
diff --git a/Godeps/LICENSES b/Godeps/LICENSES
index a7832673562..e472b668816 100644
--- a/Godeps/LICENSES
+++ b/Godeps/LICENSES
@@ -16511,216 +16511,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ================================================================================
 
 
-================================================================================
-= vendor/github.com/cockroachdb/cmux licensed under: =
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-= vendor/github.com/cockroachdb/cmux/LICENSE 3b83ef96387f14655fc854ddc3c6bd57
-================================================================================
-
-
 ================================================================================
 = vendor/github.com/codedellemc/goscaleio licensed under: =
 
@@ -24208,6 +23998,216 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ================================================================================
 
 
+================================================================================
+= vendor/github.com/coreos/etcd/etcdserver/api/v2v3 licensed under: =
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+= vendor/github.com/coreos/etcd/LICENSE 3b83ef96387f14655fc854ddc3c6bd57
+================================================================================
+
+
 ================================================================================
 = vendor/github.com/coreos/etcd/etcdserver/api/v3client licensed under: =
 
@@ -30928,216 +30928,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ================================================================================
 
 
-================================================================================
-= vendor/github.com/coreos/etcd/pkg/monotime licensed under: =
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-= vendor/github.com/coreos/etcd/LICENSE 3b83ef96387f14655fc854ddc3c6bd57
-================================================================================
-
-
 ================================================================================
 = vendor/github.com/coreos/etcd/pkg/netutil licensed under: =
 
@@ -50549,45 +50339,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ================================================================================
 
 
-================================================================================
-= vendor/github.com/golang/protobuf/protoc-gen-go/descriptor licensed under: =
-
-Go support for Protocol Buffers - Google's data interchange format
-
-Copyright 2010 The Go Authors.  All rights reserved.
-https://github.com/golang/protobuf
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-    * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-= vendor/github.com/golang/protobuf/LICENSE 14db3a56c3796a940ba32948a15f97d0
-================================================================================
-
-
 ================================================================================
 = vendor/github.com/golang/protobuf/ptypes licensed under: =
 
@@ -87423,6 +87174,216 @@ THE SOFTWARE.
 ================================================================================
 
 
+================================================================================
+= vendor/github.com/soheilhy/cmux licensed under: =
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+= vendor/github.com/soheilhy/cmux/LICENSE 3b83ef96387f14655fc854ddc3c6bd57
+================================================================================
+
+
 ================================================================================
 = vendor/github.com/spf13/afero licensed under: =
 
@@ -88818,6 +88779,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ================================================================================
 
 
+================================================================================
+= vendor/github.com/tmc/grpc-websocket-proxy/wsproxy licensed under: =
+
+Copyright (C) 2016 Travis Cline
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+= vendor/github.com/tmc/grpc-websocket-proxy/LICENSE 0894f9b225c28f0896b4bab675a2e19a
+================================================================================
+
+
 ================================================================================
 = vendor/github.com/tools/godep licensed under: =
 
@@ -100199,216 +100175,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ================================================================================
 
 
-================================================================================
-= vendor/google.golang.org/genproto/googleapis/api/annotations licensed under: =
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-= vendor/google.golang.org/genproto/LICENSE 3b83ef96387f14655fc854ddc3c6bd57
-================================================================================
-
-
 ================================================================================
 = vendor/google.golang.org/genproto/googleapis/rpc/status licensed under: =
 
@@ -102089,6 +101855,216 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ================================================================================
 
 
+================================================================================
+= vendor/google.golang.org/grpc/health licensed under: =
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+= vendor/google.golang.org/grpc/LICENSE 3b83ef96387f14655fc854ddc3c6bd57
+================================================================================
+
+
 ================================================================================
 = vendor/google.golang.org/grpc/health/grpc_health_v1 licensed under: =
 
diff --git a/cluster/images/etcd/migrate/rollback_v2.go b/cluster/images/etcd/migrate/rollback_v2.go
index ce3cfdfbd13..0d3b3ce2b01 100644
--- a/cluster/images/etcd/migrate/rollback_v2.go
+++ b/cluster/images/etcd/migrate/rollback_v2.go
@@ -314,12 +314,33 @@ func toTTLOptions(r *pb.Request) store.TTLOptionSet {
 }
 
 func applyRequest(r *pb.Request, applyV2 etcdserver.ApplierV2) {
+	// TODO: find a sane way to perform this cast or avoid it in the first place
+	reqV2 := &etcdserver.RequestV2{
+		ID:               r.ID,
+		Method:           r.Method,
+		Path:             r.Path,
+		Val:              r.Val,
+		Dir:              r.Dir,
+		PrevValue:        r.PrevValue,
+		PrevIndex:        r.PrevIndex,
+		PrevExist:        r.PrevExist,
+		Expiration:       r.Expiration,
+		Wait:             r.Wait,
+		Since:            r.Since,
+		Recursive:        r.Recursive,
+		Sorted:           r.Sorted,
+		Quorum:           r.Quorum,
+		Time:             r.Time,
+		Stream:           r.Stream,
+		Refresh:          r.Refresh,
+		XXX_unrecognized: r.XXX_unrecognized,
+	}
 	toTTLOptions(r)
 	switch r.Method {
 	case "PUT":
-		applyV2.Put(r)
+		applyV2.Put(reqV2)
 	case "DELETE":
-		applyV2.Delete(r)
+		applyV2.Delete(reqV2)
 	case "POST", "QGET", "SYNC":
 		return
 	default:
diff --git a/hack/.golint_failures b/hack/.golint_failures
index 55af91ab71b..c112d374c34 100644
--- a/hack/.golint_failures
+++ b/hack/.golint_failures
@@ -198,7 +198,6 @@ pkg/kubelet
 pkg/kubelet/apis
 pkg/kubelet/apis/config
 pkg/kubelet/apis/config/v1beta1
-pkg/kubelet/apis/cri/runtime/v1alpha2
 pkg/kubelet/apis/cri/testing
 pkg/kubelet/apis/deviceplugin/v1alpha
 pkg/kubelet/apis/deviceplugin/v1beta1
@@ -253,8 +252,6 @@ pkg/kubelet/types
 pkg/kubelet/util
 pkg/kubelet/util/cache
 pkg/kubelet/util/pluginwatcher
-pkg/kubelet/util/pluginwatcher/example_plugin_apis/v1beta1
-pkg/kubelet/util/pluginwatcher/example_plugin_apis/v1beta2
 pkg/kubelet/util/queue
 pkg/kubelet/util/sliceutils
 pkg/kubemark
@@ -617,7 +614,6 @@ staging/src/k8s.io/apiserver/pkg/storage/storagebackend
 staging/src/k8s.io/apiserver/pkg/storage/testing
 staging/src/k8s.io/apiserver/pkg/storage/tests
 staging/src/k8s.io/apiserver/pkg/storage/value
-staging/src/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/v1beta1
 staging/src/k8s.io/apiserver/pkg/util/feature
 staging/src/k8s.io/apiserver/pkg/util/flag
 staging/src/k8s.io/apiserver/pkg/util/proxy
diff --git a/hack/verify-pkg-names.sh b/hack/verify-pkg-names.sh
index 6dcd8098fb7..abb8bb96480 100755
--- a/hack/verify-pkg-names.sh
+++ b/hack/verify-pkg-names.sh
@@ -26,7 +26,7 @@ source "${KUBE_ROOT}/hack/lib/init.sh"
 kube::golang::verify_go_version
 
 cd "${KUBE_ROOT}"
-if git --no-pager grep -E $'^(import |\t)[a-z]+[A-Z_][a-zA-Z]* "[^"]+"$' -- '**/*.go' ':(exclude)vendor/*'; then
+if git --no-pager grep -E $'^(import |\t)[a-z]+[A-Z_][a-zA-Z]* "[^"]+"$' -- '**/*.go' ':(exclude)vendor/*' ':(exclude)**.*.pb.go'; then
   echo "!!! Some package aliases break go conventions."
   echo "To fix these errors, do not use capitalized or underlined characters"
   echo "in pkg aliases. Refer to https://blog.golang.org/package-names for more info."
diff --git a/pkg/kubelet/apis/cri/runtime/v1alpha2/api.pb.go b/pkg/kubelet/apis/cri/runtime/v1alpha2/api.pb.go
index ca0cb6a918d..d65bf34d2e1 100644
--- a/pkg/kubelet/apis/cri/runtime/v1alpha2/api.pb.go
+++ b/pkg/kubelet/apis/cri/runtime/v1alpha2/api.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: api.proto
-// DO NOT EDIT!
 
 /*
 	Package v1alpha2 is a generated protocol buffer package.
@@ -9046,24 +9045,6 @@ func (m *ReopenContainerLogResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Api(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Api(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -13542,51 +13523,14 @@ func (m *LinuxPodSandboxConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Sysctls == nil {
 				m.Sysctls = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -13596,41 +13540,80 @@ func (m *LinuxPodSandboxConfig) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Sysctls[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Sysctls[mapkey] = mapvalue
 			}
+			m.Sysctls[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -14019,51 +14002,14 @@ func (m *PodSandboxConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Labels == nil {
 				m.Labels = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -14073,41 +14019,80 @@ func (m *PodSandboxConfig) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Labels[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Labels[mapkey] = mapvalue
 			}
+			m.Labels[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 7:
 			if wireType != 2 {
@@ -14135,51 +14120,14 @@ func (m *PodSandboxConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -14189,41 +14137,80 @@ func (m *PodSandboxConfig) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 8:
 			if wireType != 2 {
@@ -15293,51 +15280,14 @@ func (m *PodSandboxStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Labels == nil {
 				m.Labels = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -15347,41 +15297,80 @@ func (m *PodSandboxStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Labels[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Labels[mapkey] = mapvalue
 			}
+			m.Labels[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 8:
 			if wireType != 2 {
@@ -15409,51 +15398,14 @@ func (m *PodSandboxStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -15463,41 +15415,80 @@ func (m *PodSandboxStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -15608,51 +15599,14 @@ func (m *PodSandboxStatusResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Info == nil {
 				m.Info = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -15662,41 +15616,80 @@ func (m *PodSandboxStatusResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Info[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Info[mapkey] = mapvalue
 			}
+			m.Info[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -15905,51 +15898,14 @@ func (m *PodSandboxFilter) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.LabelSelector == nil {
 				m.LabelSelector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -15959,41 +15915,80 @@ func (m *PodSandboxFilter) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.LabelSelector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.LabelSelector[mapkey] = mapvalue
 			}
+			m.LabelSelector[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -16254,51 +16249,14 @@ func (m *PodSandbox) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Labels == nil {
 				m.Labels = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -16308,41 +16266,80 @@ func (m *PodSandbox) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Labels[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Labels[mapkey] = mapvalue
 			}
+			m.Labels[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 6:
 			if wireType != 2 {
@@ -16370,51 +16367,14 @@ func (m *PodSandbox) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -16424,41 +16384,80 @@ func (m *PodSandbox) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -18681,51 +18680,14 @@ func (m *ContainerConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Labels == nil {
 				m.Labels = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -18735,41 +18697,80 @@ func (m *ContainerConfig) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Labels[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Labels[mapkey] = mapvalue
 			}
+			m.Labels[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 10:
 			if wireType != 2 {
@@ -18797,51 +18798,14 @@ func (m *ContainerConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -18851,41 +18815,80 @@ func (m *ContainerConfig) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 11:
 			if wireType != 2 {
@@ -19908,51 +19911,14 @@ func (m *ContainerFilter) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.LabelSelector == nil {
 				m.LabelSelector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -19962,41 +19928,80 @@ func (m *ContainerFilter) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.LabelSelector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.LabelSelector[mapkey] = mapvalue
 			}
+			m.LabelSelector[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -20348,51 +20353,14 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Labels == nil {
 				m.Labels = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -20402,41 +20370,80 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Labels[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Labels[mapkey] = mapvalue
 			}
+			m.Labels[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 9:
 			if wireType != 2 {
@@ -20464,51 +20471,14 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -20518,41 +20488,80 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -21087,51 +21096,14 @@ func (m *ContainerStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Labels == nil {
 				m.Labels = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -21141,41 +21113,80 @@ func (m *ContainerStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Labels[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Labels[mapkey] = mapvalue
 			}
+			m.Labels[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 13:
 			if wireType != 2 {
@@ -21203,51 +21214,14 @@ func (m *ContainerStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -21257,41 +21231,80 @@ func (m *ContainerStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 14:
 			if wireType != 2 {
@@ -21462,51 +21475,14 @@ func (m *ContainerStatusResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Info == nil {
 				m.Info = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -21516,41 +21492,80 @@ func (m *ContainerStatusResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Info[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Info[mapkey] = mapvalue
 			}
+			m.Info[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -23374,51 +23389,14 @@ func (m *ImageStatusResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Info == nil {
 				m.Info = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -23428,41 +23406,80 @@ func (m *ImageStatusResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Info[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Info[mapkey] = mapvalue
 			}
+			m.Info[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -24761,51 +24778,14 @@ func (m *StatusResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Info == nil {
 				m.Info = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -24815,41 +24795,80 @@ func (m *StatusResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Info[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Info[mapkey] = mapvalue
 			}
+			m.Info[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -25677,51 +25696,14 @@ func (m *ContainerStatsFilter) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.LabelSelector == nil {
 				m.LabelSelector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -25731,41 +25713,80 @@ func (m *ContainerStatsFilter) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.LabelSelector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.LabelSelector[mapkey] = mapvalue
 			}
+			m.LabelSelector[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -25986,51 +26007,14 @@ func (m *ContainerAttributes) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Labels == nil {
 				m.Labels = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -26040,41 +26024,80 @@ func (m *ContainerAttributes) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Labels[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Labels[mapkey] = mapvalue
 			}
+			m.Labels[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
@@ -26102,51 +26125,14 @@ func (m *ContainerAttributes) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -26156,41 +26142,80 @@ func (m *ContainerAttributes) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/pkg/kubelet/apis/deviceplugin/v1alpha/api.pb.go b/pkg/kubelet/apis/deviceplugin/v1alpha/api.pb.go
index 75fbbfeea68..cfe7ea7054f 100644
--- a/pkg/kubelet/apis/deviceplugin/v1alpha/api.pb.go
+++ b/pkg/kubelet/apis/deviceplugin/v1alpha/api.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: api.proto
-// DO NOT EDIT!
 
 /*
 	Package deviceplugin is a generated protocol buffer package.
@@ -820,24 +819,6 @@ func (m *DeviceSpec) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Api(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Api(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1618,51 +1599,14 @@ func (m *AllocateResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Envs == nil {
 				m.Envs = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -1672,41 +1616,80 @@ func (m *AllocateResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Envs[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Envs[mapkey] = mapvalue
 			}
+			m.Envs[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -1796,51 +1779,14 @@ func (m *AllocateResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -1850,41 +1796,80 @@ func (m *AllocateResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/pkg/kubelet/apis/deviceplugin/v1beta1/api.pb.go b/pkg/kubelet/apis/deviceplugin/v1beta1/api.pb.go
index 2aeb99f3bab..839a37b0d56 100644
--- a/pkg/kubelet/apis/deviceplugin/v1beta1/api.pb.go
+++ b/pkg/kubelet/apis/deviceplugin/v1beta1/api.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: api.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -1137,24 +1136,6 @@ func (m *DeviceSpec) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Api(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Api(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -2434,51 +2415,14 @@ func (m *ContainerAllocateResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Envs == nil {
 				m.Envs = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -2488,41 +2432,80 @@ func (m *ContainerAllocateResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Envs[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Envs[mapkey] = mapvalue
 			}
+			m.Envs[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -2612,51 +2595,14 @@ func (m *ContainerAllocateResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowApi
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthApi
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowApi
@@ -2666,41 +2612,80 @@ func (m *ContainerAllocateResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowApi
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthApi
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/pkg/kubelet/apis/pluginregistration/v1alpha1/api.pb.go b/pkg/kubelet/apis/pluginregistration/v1alpha1/api.pb.go
index 96e1d571dba..d478726ab25 100644
--- a/pkg/kubelet/apis/pluginregistration/v1alpha1/api.pb.go
+++ b/pkg/kubelet/apis/pluginregistration/v1alpha1/api.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: api.proto
-// DO NOT EDIT!
 
 /*
 	Package pluginregistration is a generated protocol buffer package.
@@ -389,24 +388,6 @@ func (m *InfoRequest) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Api(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Api(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/pkg/kubelet/apis/pluginregistration/v1beta1/api.pb.go b/pkg/kubelet/apis/pluginregistration/v1beta1/api.pb.go
index 96e1d571dba..d478726ab25 100644
--- a/pkg/kubelet/apis/pluginregistration/v1beta1/api.pb.go
+++ b/pkg/kubelet/apis/pluginregistration/v1beta1/api.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: api.proto
-// DO NOT EDIT!
 
 /*
 	Package pluginregistration is a generated protocol buffer package.
@@ -389,24 +388,6 @@ func (m *InfoRequest) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Api(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Api(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/pkg/kubelet/util/pluginwatcher/example_plugin_apis/v1beta1/api.pb.go b/pkg/kubelet/util/pluginwatcher/example_plugin_apis/v1beta1/api.pb.go
index 671e3df493b..296dc91fc46 100644
--- a/pkg/kubelet/util/pluginwatcher/example_plugin_apis/v1beta1/api.pb.go
+++ b/pkg/kubelet/util/pluginwatcher/example_plugin_apis/v1beta1/api.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: api.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -225,24 +224,6 @@ func (m *ExampleResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Api(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Api(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/pkg/kubelet/util/pluginwatcher/example_plugin_apis/v1beta2/api.pb.go b/pkg/kubelet/util/pluginwatcher/example_plugin_apis/v1beta2/api.pb.go
index 0c63b31429f..73f36b7bef0 100644
--- a/pkg/kubelet/util/pluginwatcher/example_plugin_apis/v1beta2/api.pb.go
+++ b/pkg/kubelet/util/pluginwatcher/example_plugin_apis/v1beta2/api.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: api.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta2 is a generated protocol buffer package.
@@ -226,24 +225,6 @@ func (m *ExampleResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Api(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Api(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/Godeps/Godeps.json b/staging/src/k8s.io/api/Godeps/Godeps.json
index 7fa23517871..65e38dc8f1f 100644
--- a/staging/src/k8s.io/api/Godeps/Godeps.json
+++ b/staging/src/k8s.io/api/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/api",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -16,11 +16,11 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/api/admission/v1beta1/generated.pb.go b/staging/src/k8s.io/api/admission/v1beta1/generated.pb.go
index d2b938e5a27..4082082ff94 100644
--- a/staging/src/k8s.io/api/admission/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/admission/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/admission/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -274,24 +273,6 @@ func (m *AdmissionReview) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1014,51 +995,14 @@ func (m *AdmissionResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.AuditAnnotations == nil {
 				m.AuditAnnotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1068,41 +1012,80 @@ func (m *AdmissionResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.AuditAnnotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.AuditAnnotations[mapkey] = mapvalue
 			}
+			m.AuditAnnotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/staging/src/k8s.io/api/admissionregistration/v1alpha1/generated.pb.go b/staging/src/k8s.io/api/admissionregistration/v1alpha1/generated.pb.go
index b87f74e5207..74c467a2223 100644
--- a/staging/src/k8s.io/api/admissionregistration/v1alpha1/generated.pb.go
+++ b/staging/src/k8s.io/api/admissionregistration/v1alpha1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/admissionregistration/v1alpha1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1alpha1 is a generated protocol buffer package.
@@ -251,24 +250,6 @@ func (m *Rule) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/admissionregistration/v1beta1/generated.pb.go b/staging/src/k8s.io/api/admissionregistration/v1beta1/generated.pb.go
index d6c9d958bf5..2ca3fa6524f 100644
--- a/staging/src/k8s.io/api/admissionregistration/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/admissionregistration/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/admissionregistration/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -506,24 +505,6 @@ func (m *WebhookClientConfig) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/apps/v1/generated.pb.go b/staging/src/k8s.io/api/apps/v1/generated.pb.go
index eac6ef2a12c..5b29f432080 100644
--- a/staging/src/k8s.io/api/apps/v1/generated.pb.go
+++ b/staging/src/k8s.io/api/apps/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/apps/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -1440,24 +1439,6 @@ func (m *StatefulSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/apps/v1beta1/generated.pb.go b/staging/src/k8s.io/api/apps/v1beta1/generated.pb.go
index ef9aa8e09f0..93530475540 100644
--- a/staging/src/k8s.io/api/apps/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/apps/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/apps/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -1091,24 +1090,6 @@ func (m *StatefulSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -2552,51 +2533,14 @@ func (m *DeploymentRollback) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.UpdatedAnnotations == nil {
 				m.UpdatedAnnotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -2606,41 +2550,80 @@ func (m *DeploymentRollback) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.UpdatedAnnotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.UpdatedAnnotations[mapkey] = mapvalue
 			}
+			m.UpdatedAnnotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -3833,51 +3816,14 @@ func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Selector == nil {
 				m.Selector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -3887,41 +3833,80 @@ func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Selector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Selector[mapkey] = mapvalue
 			}
+			m.Selector[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/api/apps/v1beta2/generated.pb.go b/staging/src/k8s.io/api/apps/v1beta2/generated.pb.go
index 72d832c3407..fc1efbc90bc 100644
--- a/staging/src/k8s.io/api/apps/v1beta2/generated.pb.go
+++ b/staging/src/k8s.io/api/apps/v1beta2/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/apps/v1beta2/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta2 is a generated protocol buffer package.
@@ -1570,24 +1569,6 @@ func (m *StatefulSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -6109,51 +6090,14 @@ func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Selector == nil {
 				m.Selector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -6163,41 +6107,80 @@ func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Selector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Selector[mapkey] = mapvalue
 			}
+			m.Selector[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/api/authentication/v1/generated.pb.go b/staging/src/k8s.io/api/authentication/v1/generated.pb.go
index 2ce2e2d78e0..dcea42283cb 100644
--- a/staging/src/k8s.io/api/authentication/v1/generated.pb.go
+++ b/staging/src/k8s.io/api/authentication/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/authentication/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -469,24 +468,6 @@ func (m *UserInfo) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1861,51 +1842,14 @@ func (m *UserInfo) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Extra == nil {
 				m.Extra = make(map[string]ExtraValue)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := &ExtraValue{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1915,46 +1859,85 @@ func (m *UserInfo) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &ExtraValue{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &ExtraValue{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Extra[mapkey] = *mapvalue
-			} else {
-				var mapvalue ExtraValue
-				m.Extra[mapkey] = mapvalue
 			}
+			m.Extra[mapkey] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/staging/src/k8s.io/api/authentication/v1beta1/generated.pb.go b/staging/src/k8s.io/api/authentication/v1beta1/generated.pb.go
index 8503d212baa..55886b47818 100644
--- a/staging/src/k8s.io/api/authentication/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/authentication/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/authentication/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -289,24 +288,6 @@ func (m *UserInfo) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1031,51 +1012,14 @@ func (m *UserInfo) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Extra == nil {
 				m.Extra = make(map[string]ExtraValue)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := &ExtraValue{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1085,46 +1029,85 @@ func (m *UserInfo) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &ExtraValue{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &ExtraValue{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Extra[mapkey] = *mapvalue
-			} else {
-				var mapvalue ExtraValue
-				m.Extra[mapkey] = mapvalue
 			}
+			m.Extra[mapkey] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/staging/src/k8s.io/api/authorization/v1/generated.pb.go b/staging/src/k8s.io/api/authorization/v1/generated.pb.go
index e9145af0261..fc6a25f6299 100644
--- a/staging/src/k8s.io/api/authorization/v1/generated.pb.go
+++ b/staging/src/k8s.io/api/authorization/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/authorization/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -795,24 +794,6 @@ func (m *SubjectRulesReviewStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -2888,51 +2869,14 @@ func (m *SubjectAccessReviewSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Extra == nil {
 				m.Extra = make(map[string]ExtraValue)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := &ExtraValue{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -2942,46 +2886,85 @@ func (m *SubjectAccessReviewSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &ExtraValue{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &ExtraValue{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Extra[mapkey] = *mapvalue
-			} else {
-				var mapvalue ExtraValue
-				m.Extra[mapkey] = mapvalue
 			}
+			m.Extra[mapkey] = *mapvalue
 			iNdEx = postIndex
 		case 6:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/api/authorization/v1beta1/generated.pb.go b/staging/src/k8s.io/api/authorization/v1beta1/generated.pb.go
index 75ee6cf918f..7cce98eb195 100644
--- a/staging/src/k8s.io/api/authorization/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/authorization/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/authorization/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -795,24 +794,6 @@ func (m *SubjectRulesReviewStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -2888,51 +2869,14 @@ func (m *SubjectAccessReviewSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Extra == nil {
 				m.Extra = make(map[string]ExtraValue)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := &ExtraValue{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -2942,46 +2886,85 @@ func (m *SubjectAccessReviewSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &ExtraValue{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &ExtraValue{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Extra[mapkey] = *mapvalue
-			} else {
-				var mapvalue ExtraValue
-				m.Extra[mapkey] = mapvalue
 			}
+			m.Extra[mapkey] = *mapvalue
 			iNdEx = postIndex
 		case 6:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/api/autoscaling/v1/generated.pb.go b/staging/src/k8s.io/api/autoscaling/v1/generated.pb.go
index 47a46a5574e..950e93340d6 100644
--- a/staging/src/k8s.io/api/autoscaling/v1/generated.pb.go
+++ b/staging/src/k8s.io/api/autoscaling/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/autoscaling/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -996,24 +995,6 @@ func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/autoscaling/v2beta1/generated.pb.go b/staging/src/k8s.io/api/autoscaling/v2beta1/generated.pb.go
index bee94129d8e..b6a5f35629b 100644
--- a/staging/src/k8s.io/api/autoscaling/v2beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/autoscaling/v2beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/autoscaling/v2beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v2beta1 is a generated protocol buffer package.
@@ -916,24 +915,6 @@ func (m *ResourceMetricStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/autoscaling/v2beta2/generated.pb.go b/staging/src/k8s.io/api/autoscaling/v2beta2/generated.pb.go
index be752a14025..816fea9d532 100644
--- a/staging/src/k8s.io/api/autoscaling/v2beta2/generated.pb.go
+++ b/staging/src/k8s.io/api/autoscaling/v2beta2/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/autoscaling/v2beta2/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v2beta2 is a generated protocol buffer package.
@@ -966,24 +965,6 @@ func (m *ResourceMetricStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/batch/v1/generated.pb.go b/staging/src/k8s.io/api/batch/v1/generated.pb.go
index 097a6ff28c5..3aa32b57846 100644
--- a/staging/src/k8s.io/api/batch/v1/generated.pb.go
+++ b/staging/src/k8s.io/api/batch/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/batch/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -343,24 +342,6 @@ func (m *JobStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/batch/v1beta1/generated.pb.go b/staging/src/k8s.io/api/batch/v1beta1/generated.pb.go
index ece2204f932..36342a3af1a 100644
--- a/staging/src/k8s.io/api/batch/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/batch/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/batch/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -336,24 +335,6 @@ func (m *JobTemplateSpec) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/batch/v2alpha1/generated.pb.go b/staging/src/k8s.io/api/batch/v2alpha1/generated.pb.go
index 6ab41ebbcb3..4d9ba5c0004 100644
--- a/staging/src/k8s.io/api/batch/v2alpha1/generated.pb.go
+++ b/staging/src/k8s.io/api/batch/v2alpha1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/batch/v2alpha1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v2alpha1 is a generated protocol buffer package.
@@ -336,24 +335,6 @@ func (m *JobTemplateSpec) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/certificates/v1beta1/generated.pb.go b/staging/src/k8s.io/api/certificates/v1beta1/generated.pb.go
index eda1599005a..19bf225fa31 100644
--- a/staging/src/k8s.io/api/certificates/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/certificates/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/certificates/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -378,24 +377,6 @@ func (m ExtraValue) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1221,51 +1202,14 @@ func (m *CertificateSigningRequestSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Extra == nil {
 				m.Extra = make(map[string]ExtraValue)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := &ExtraValue{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1275,46 +1219,85 @@ func (m *CertificateSigningRequestSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &ExtraValue{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &ExtraValue{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Extra[mapkey] = *mapvalue
-			} else {
-				var mapvalue ExtraValue
-				m.Extra[mapkey] = mapvalue
 			}
+			m.Extra[mapkey] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/staging/src/k8s.io/api/coordination/v1beta1/generated.pb.go b/staging/src/k8s.io/api/coordination/v1beta1/generated.pb.go
index 6c2dbd91f9a..aa57e9dd644 100644
--- a/staging/src/k8s.io/api/coordination/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/coordination/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/coordination/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -196,24 +195,6 @@ func (m *LeaseSpec) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/core/v1/generated.pb.go b/staging/src/k8s.io/api/core/v1/generated.pb.go
index c9ce92523fd..80e8aad5f36 100644
--- a/staging/src/k8s.io/api/core/v1/generated.pb.go
+++ b/staging/src/k8s.io/api/core/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/core/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -10958,24 +10957,6 @@ func (m *WeightedPodAffinityTerm) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -18573,51 +18554,14 @@ func (m *CSIPersistentVolumeSource) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.VolumeAttributes == nil {
 				m.VolumeAttributes = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -18627,41 +18571,80 @@ func (m *CSIPersistentVolumeSource) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.VolumeAttributes[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.VolumeAttributes[mapkey] = mapvalue
 			}
+			m.VolumeAttributes[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 6:
 			if wireType != 2 {
@@ -20194,51 +20177,14 @@ func (m *ConfigMap) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Data == nil {
 				m.Data = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -20248,41 +20194,80 @@ func (m *ConfigMap) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Data[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Data[mapkey] = mapvalue
 			}
+			m.Data[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -20310,51 +20295,14 @@ func (m *ConfigMap) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.BinaryData == nil {
 				m.BinaryData = make(map[string][]byte)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := []byte{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -20364,42 +20312,81 @@ func (m *ConfigMap) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapbyteLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapbyteLen |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapbyteLen uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapbyteLen |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intMapbyteLen := int(mapbyteLen)
+					if intMapbyteLen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postbytesIndex := iNdEx + intMapbyteLen
+					if postbytesIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = make([]byte, mapbyteLen)
+					copy(mapvalue, dAtA[iNdEx:postbytesIndex])
+					iNdEx = postbytesIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intMapbyteLen := int(mapbyteLen)
-				if intMapbyteLen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postbytesIndex := iNdEx + intMapbyteLen
-				if postbytesIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := make([]byte, mapbyteLen)
-				copy(mapvalue, dAtA[iNdEx:postbytesIndex])
-				iNdEx = postbytesIndex
-				m.BinaryData[mapkey] = mapvalue
-			} else {
-				var mapvalue []byte
-				m.BinaryData[mapkey] = mapvalue
 			}
+			m.BinaryData[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -25929,51 +25916,14 @@ func (m *FlexPersistentVolumeSource) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Options == nil {
 				m.Options = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -25983,41 +25933,80 @@ func (m *FlexPersistentVolumeSource) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Options[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Options[mapkey] = mapvalue
 			}
+			m.Options[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -26206,51 +26195,14 @@ func (m *FlexVolumeSource) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Options == nil {
 				m.Options = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -26260,41 +26212,80 @@ func (m *FlexVolumeSource) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Options[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Options[mapkey] = mapvalue
 			}
+			m.Options[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -28621,51 +28612,14 @@ func (m *LimitRangeItem) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Max == nil {
 				m.Max = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -28675,46 +28629,85 @@ func (m *LimitRangeItem) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Max[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Max[ResourceName(mapkey)] = mapvalue
 			}
+			m.Max[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -28742,51 +28735,14 @@ func (m *LimitRangeItem) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Min == nil {
 				m.Min = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -28796,46 +28752,85 @@ func (m *LimitRangeItem) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Min[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Min[ResourceName(mapkey)] = mapvalue
 			}
+			m.Min[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
@@ -28863,51 +28858,14 @@ func (m *LimitRangeItem) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Default == nil {
 				m.Default = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -28917,46 +28875,85 @@ func (m *LimitRangeItem) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Default[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Default[ResourceName(mapkey)] = mapvalue
 			}
+			m.Default[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 5:
 			if wireType != 2 {
@@ -28984,51 +28981,14 @@ func (m *LimitRangeItem) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.DefaultRequest == nil {
 				m.DefaultRequest = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -29038,46 +28998,85 @@ func (m *LimitRangeItem) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.DefaultRequest[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.DefaultRequest[ResourceName(mapkey)] = mapvalue
 			}
+			m.DefaultRequest[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 6:
 			if wireType != 2 {
@@ -29105,51 +29104,14 @@ func (m *LimitRangeItem) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.MaxLimitRequestRatio == nil {
 				m.MaxLimitRequestRatio = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -29159,46 +29121,85 @@ func (m *LimitRangeItem) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.MaxLimitRequestRatio[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.MaxLimitRequestRatio[ResourceName(mapkey)] = mapvalue
 			}
+			m.MaxLimitRequestRatio[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -31612,51 +31613,14 @@ func (m *NodeResources) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Capacity == nil {
 				m.Capacity = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -31666,46 +31630,85 @@ func (m *NodeResources) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Capacity[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Capacity[ResourceName(mapkey)] = mapvalue
 			}
+			m.Capacity[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -32334,51 +32337,14 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Capacity == nil {
 				m.Capacity = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -32388,46 +32354,85 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Capacity[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Capacity[ResourceName(mapkey)] = mapvalue
 			}
+			m.Capacity[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -32455,51 +32460,14 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Allocatable == nil {
 				m.Allocatable = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -32509,46 +32477,85 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Allocatable[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Allocatable[ResourceName(mapkey)] = mapvalue
 			}
+			m.Allocatable[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -34541,51 +34548,14 @@ func (m *PersistentVolumeClaimStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Capacity == nil {
 				m.Capacity = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -34595,46 +34565,85 @@ func (m *PersistentVolumeClaimStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Capacity[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Capacity[ResourceName(mapkey)] = mapvalue
 			}
+			m.Capacity[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
@@ -35729,51 +35738,14 @@ func (m *PersistentVolumeSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Capacity == nil {
 				m.Capacity = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -35783,46 +35755,85 @@ func (m *PersistentVolumeSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Capacity[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Capacity[ResourceName(mapkey)] = mapvalue
 			}
+			m.Capacity[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -38826,51 +38837,14 @@ func (m *PodSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.NodeSelector == nil {
 				m.NodeSelector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -38880,41 +38854,80 @@ func (m *PodSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.NodeSelector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.NodeSelector[mapkey] = mapvalue
 			}
+			m.NodeSelector[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 8:
 			if wireType != 2 {
@@ -42540,51 +42553,14 @@ func (m *ReplicationControllerSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Selector == nil {
 				m.Selector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -42594,41 +42570,80 @@ func (m *ReplicationControllerSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Selector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Selector[mapkey] = mapvalue
 			}
+			m.Selector[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -43323,51 +43338,14 @@ func (m *ResourceQuotaSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Hard == nil {
 				m.Hard = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -43377,46 +43355,85 @@ func (m *ResourceQuotaSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Hard[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Hard[ResourceName(mapkey)] = mapvalue
 			}
+			m.Hard[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -43556,51 +43573,14 @@ func (m *ResourceQuotaStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Hard == nil {
 				m.Hard = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -43610,46 +43590,85 @@ func (m *ResourceQuotaStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Hard[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Hard[ResourceName(mapkey)] = mapvalue
 			}
+			m.Hard[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -43677,51 +43696,14 @@ func (m *ResourceQuotaStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Used == nil {
 				m.Used = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -43731,46 +43713,85 @@ func (m *ResourceQuotaStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Used[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Used[ResourceName(mapkey)] = mapvalue
 			}
+			m.Used[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -43848,51 +43869,14 @@ func (m *ResourceRequirements) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Limits == nil {
 				m.Limits = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -43902,46 +43886,85 @@ func (m *ResourceRequirements) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Limits[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Limits[ResourceName(mapkey)] = mapvalue
 			}
+			m.Limits[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -43969,51 +43992,14 @@ func (m *ResourceRequirements) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Requests == nil {
 				m.Requests = make(ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -44023,46 +44009,85 @@ func (m *ResourceRequirements) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Requests[ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Requests[ResourceName(mapkey)] = mapvalue
 			}
+			m.Requests[ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -45206,51 +45231,14 @@ func (m *Secret) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Data == nil {
 				m.Data = make(map[string][]byte)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := []byte{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -45260,42 +45248,81 @@ func (m *Secret) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapbyteLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapbyteLen |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapbyteLen uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapbyteLen |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intMapbyteLen := int(mapbyteLen)
+					if intMapbyteLen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postbytesIndex := iNdEx + intMapbyteLen
+					if postbytesIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = make([]byte, mapbyteLen)
+					copy(mapvalue, dAtA[iNdEx:postbytesIndex])
+					iNdEx = postbytesIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intMapbyteLen := int(mapbyteLen)
-				if intMapbyteLen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postbytesIndex := iNdEx + intMapbyteLen
-				if postbytesIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := make([]byte, mapbyteLen)
-				copy(mapvalue, dAtA[iNdEx:postbytesIndex])
-				iNdEx = postbytesIndex
-				m.Data[mapkey] = mapvalue
-			} else {
-				var mapvalue []byte
-				m.Data[mapkey] = mapvalue
 			}
+			m.Data[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -45352,51 +45379,14 @@ func (m *Secret) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.StringData == nil {
 				m.StringData = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -45406,41 +45396,80 @@ func (m *Secret) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.StringData[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.StringData[mapkey] = mapvalue
 			}
+			m.StringData[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -47540,51 +47569,14 @@ func (m *ServiceSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Selector == nil {
 				m.Selector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -47594,41 +47586,80 @@ func (m *ServiceSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Selector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Selector[mapkey] = mapvalue
 			}
+			m.Selector[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/api/events/v1beta1/generated.pb.go b/staging/src/k8s.io/api/events/v1beta1/generated.pb.go
index e24a82ab186..bb0c881b571 100644
--- a/staging/src/k8s.io/api/events/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/events/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/events/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -254,24 +253,6 @@ func (m *EventSeries) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/extensions/v1beta1/generated.pb.go b/staging/src/k8s.io/api/extensions/v1beta1/generated.pb.go
index 72d64db3edd..5415ddfb0aa 100644
--- a/staging/src/k8s.io/api/extensions/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/extensions/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -2837,24 +2836,6 @@ func (m *SupplementalGroupsStrategyOptions) MarshalTo(dAtA []byte) (int, error)
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -6597,51 +6578,14 @@ func (m *DeploymentRollback) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.UpdatedAnnotations == nil {
 				m.UpdatedAnnotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -6651,41 +6595,80 @@ func (m *DeploymentRollback) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.UpdatedAnnotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.UpdatedAnnotations[mapkey] = mapvalue
 			}
+			m.UpdatedAnnotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -12114,51 +12097,14 @@ func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Selector == nil {
 				m.Selector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -12168,41 +12114,80 @@ func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Selector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Selector[mapkey] = mapvalue
 			}
+			m.Selector[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/api/imagepolicy/v1alpha1/generated.pb.go b/staging/src/k8s.io/api/imagepolicy/v1alpha1/generated.pb.go
index 6e08dcca84b..2a4529bfca9 100644
--- a/staging/src/k8s.io/api/imagepolicy/v1alpha1/generated.pb.go
+++ b/staging/src/k8s.io/api/imagepolicy/v1alpha1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/imagepolicy/v1alpha1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1alpha1 is a generated protocol buffer package.
@@ -250,24 +249,6 @@ func (m *ImageReviewStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -728,51 +709,14 @@ func (m *ImageReviewSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -782,41 +726,80 @@ func (m *ImageReviewSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -972,51 +955,14 @@ func (m *ImageReviewStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.AuditAnnotations == nil {
 				m.AuditAnnotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1026,41 +972,80 @@ func (m *ImageReviewStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.AuditAnnotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.AuditAnnotations[mapkey] = mapvalue
 			}
+			m.AuditAnnotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/staging/src/k8s.io/api/networking/v1/generated.pb.go b/staging/src/k8s.io/api/networking/v1/generated.pb.go
index 7b1c04b29a5..86bd80c857b 100644
--- a/staging/src/k8s.io/api/networking/v1/generated.pb.go
+++ b/staging/src/k8s.io/api/networking/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/networking/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -446,24 +445,6 @@ func (m *NetworkPolicySpec) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/policy/v1beta1/generated.pb.go b/staging/src/k8s.io/api/policy/v1beta1/generated.pb.go
index d7d62dd3ab8..97d0620fd69 100644
--- a/staging/src/k8s.io/api/policy/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/policy/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/policy/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -956,24 +955,6 @@ func (m *SupplementalGroupsStrategyOptions) MarshalTo(dAtA []byte) (int, error)
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -2537,51 +2518,14 @@ func (m *PodDisruptionBudgetStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.DisruptedPods == nil {
 				m.DisruptedPods = make(map[string]k8s_io_apimachinery_pkg_apis_meta_v1.Time)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := &k8s_io_apimachinery_pkg_apis_meta_v1.Time{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -2591,46 +2535,85 @@ func (m *PodDisruptionBudgetStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_apis_meta_v1.Time{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_apis_meta_v1.Time{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.DisruptedPods[mapkey] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_apis_meta_v1.Time
-				m.DisruptedPods[mapkey] = mapvalue
 			}
+			m.DisruptedPods[mapkey] = *mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 0 {
diff --git a/staging/src/k8s.io/api/rbac/v1/generated.pb.go b/staging/src/k8s.io/api/rbac/v1/generated.pb.go
index 21010fbeeaf..708db3276ed 100644
--- a/staging/src/k8s.io/api/rbac/v1/generated.pb.go
+++ b/staging/src/k8s.io/api/rbac/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/rbac/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -641,24 +640,6 @@ func (m *Subject) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/rbac/v1alpha1/generated.pb.go b/staging/src/k8s.io/api/rbac/v1alpha1/generated.pb.go
index 71eced8d4ec..e035b331fa5 100644
--- a/staging/src/k8s.io/api/rbac/v1alpha1/generated.pb.go
+++ b/staging/src/k8s.io/api/rbac/v1alpha1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/rbac/v1alpha1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1alpha1 is a generated protocol buffer package.
@@ -641,24 +640,6 @@ func (m *Subject) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/rbac/v1beta1/generated.pb.go b/staging/src/k8s.io/api/rbac/v1beta1/generated.pb.go
index 71e5799e3e6..904a6e7a2dc 100644
--- a/staging/src/k8s.io/api/rbac/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/rbac/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/rbac/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -641,24 +640,6 @@ func (m *Subject) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/scheduling/v1alpha1/generated.pb.go b/staging/src/k8s.io/api/scheduling/v1alpha1/generated.pb.go
index 97c07c98413..0a0d481a287 100644
--- a/staging/src/k8s.io/api/scheduling/v1alpha1/generated.pb.go
+++ b/staging/src/k8s.io/api/scheduling/v1alpha1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/scheduling/v1alpha1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1alpha1 is a generated protocol buffer package.
@@ -141,24 +140,6 @@ func (m *PriorityClassList) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/scheduling/v1beta1/generated.pb.go b/staging/src/k8s.io/api/scheduling/v1beta1/generated.pb.go
index ea8f8d5e6e3..ddb285446b7 100644
--- a/staging/src/k8s.io/api/scheduling/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/scheduling/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/scheduling/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -141,24 +140,6 @@ func (m *PriorityClassList) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/settings/v1alpha1/generated.pb.go b/staging/src/k8s.io/api/settings/v1alpha1/generated.pb.go
index 15285bae508..c842131057a 100644
--- a/staging/src/k8s.io/api/settings/v1alpha1/generated.pb.go
+++ b/staging/src/k8s.io/api/settings/v1alpha1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/settings/v1alpha1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1alpha1 is a generated protocol buffer package.
@@ -216,24 +215,6 @@ func (m *PodPresetSpec) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/api/storage/v1/generated.pb.go b/staging/src/k8s.io/api/storage/v1/generated.pb.go
index d43a982981d..9ad0a015d85 100644
--- a/staging/src/k8s.io/api/storage/v1/generated.pb.go
+++ b/staging/src/k8s.io/api/storage/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/storage/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -205,24 +204,6 @@ func (m *StorageClassList) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -460,51 +441,14 @@ func (m *StorageClass) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Parameters == nil {
 				m.Parameters = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -514,41 +458,80 @@ func (m *StorageClass) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Parameters[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Parameters[mapkey] = mapvalue
 			}
+			m.Parameters[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/api/storage/v1alpha1/generated.pb.go b/staging/src/k8s.io/api/storage/v1alpha1/generated.pb.go
index 507b5c1d5e6..0511ccabd81 100644
--- a/staging/src/k8s.io/api/storage/v1alpha1/generated.pb.go
+++ b/staging/src/k8s.io/api/storage/v1alpha1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/storage/v1alpha1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1alpha1 is a generated protocol buffer package.
@@ -324,24 +323,6 @@ func (m *VolumeError) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1076,51 +1057,14 @@ func (m *VolumeAttachmentStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.AttachmentMetadata == nil {
 				m.AttachmentMetadata = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1130,41 +1074,80 @@ func (m *VolumeAttachmentStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.AttachmentMetadata[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.AttachmentMetadata[mapkey] = mapvalue
 			}
+			m.AttachmentMetadata[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/api/storage/v1beta1/generated.pb.go b/staging/src/k8s.io/api/storage/v1beta1/generated.pb.go
index fed8c7a6308..3e995f039fc 100644
--- a/staging/src/k8s.io/api/storage/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/storage/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/api/storage/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -477,24 +476,6 @@ func (m *VolumeError) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -892,51 +873,14 @@ func (m *StorageClass) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Parameters == nil {
 				m.Parameters = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -946,41 +890,80 @@ func (m *StorageClass) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Parameters[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Parameters[mapkey] = mapvalue
 			}
+			m.Parameters[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
@@ -1799,51 +1782,14 @@ func (m *VolumeAttachmentStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.AttachmentMetadata == nil {
 				m.AttachmentMetadata = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1853,41 +1799,80 @@ func (m *VolumeAttachmentStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.AttachmentMetadata[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.AttachmentMetadata[mapkey] = mapvalue
 			}
+			m.AttachmentMetadata[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/apiextensions-apiserver/Godeps/Godeps.json b/staging/src/k8s.io/apiextensions-apiserver/Godeps/Godeps.json
index 9acff35e7fe..894ee0ce3ec 100644
--- a/staging/src/k8s.io/apiextensions-apiserver/Godeps/Godeps.json
+++ b/staging/src/k8s.io/apiextensions-apiserver/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/apiextensions-apiserver",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -38,305 +38,301 @@
 			"ImportPath": "github.com/beorn7/perks/quantile",
 			"Rev": "3ac7bf7a47d159a033b107610db8a1b6575507a4"
 		},
-		{
-			"ImportPath": "github.com/cockroachdb/cmux",
-			"Rev": "112f0506e7743d64a6eb8fedbcff13d9979bbf92"
-		},
 		{
 			"ImportPath": "github.com/coreos/bbolt",
 			"Rev": "48ea1b39c25fc1bab3506fbc712ecbaa842c4d2d"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/alarm",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/auth",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/auth/authpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/client",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3/concurrency",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3/namespace",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3/naming",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/compactor",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/discovery",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/embed",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/error",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/etcdhttp",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v2http",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v2http/httptypes",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
+		},
+		{
+			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v2v3",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3client",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3election",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/gw",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3lock",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/gw",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3rpc",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/auth",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/etcdserverpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/etcdserverpb/gw",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/membership",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/stats",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/integration",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/lease",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/lease/leasehttp",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/lease/leasepb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc/backend",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc/mvccpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/adt",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/contention",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/cors",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/cpuutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/crc",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/debugutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/fileutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/httputil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/idutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/ioutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/logutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
-		},
-		{
-			"ImportPath": "github.com/coreos/etcd/pkg/monotime",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/netutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/pathutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/pbutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/runtime",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/schedule",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/srv",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/testutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/tlsutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/transport",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/types",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/wait",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/proxy/grpcproxy",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/proxy/grpcproxy/adapter",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/proxy/grpcproxy/cache",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/raft",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/raft/raftpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/rafthttp",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/snap",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/snap/snappb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/store",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/version",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/wal",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/wal/walpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-semver/semver",
@@ -434,13 +430,21 @@
 			"ImportPath": "github.com/go-openapi/validate",
 			"Rev": "d509235108fcf6ab4913d2dcb3a2260c0db2108e"
 		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/gogoproto",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/descriptor",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
@@ -458,10 +462,6 @@
 			"ImportPath": "github.com/golang/protobuf/proto",
 			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
 		},
-		{
-			"ImportPath": "github.com/golang/protobuf/protoc-gen-go/descriptor",
-			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
-		},
 		{
 			"ImportPath": "github.com/golang/protobuf/ptypes",
 			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
@@ -502,6 +502,10 @@
 			"ImportPath": "github.com/googleapis/gnostic/extensions",
 			"Rev": "0c5108395e2debce0d731cf0287ddf7242066aba"
 		},
+		{
+			"ImportPath": "github.com/gorilla/websocket",
+			"Rev": "4201258b820c74ac8e6922fc9e6b52f71fe46f8d"
+		},
 		{
 			"ImportPath": "github.com/gregjones/httpcache",
 			"Rev": "787624de3eb7bd915c329cba748687a3b22666a6"
@@ -590,6 +594,10 @@
 			"ImportPath": "github.com/prometheus/client_golang/prometheus",
 			"Rev": "e7e903064f5e9eb5da98208bae10b475d4db0f8c"
 		},
+		{
+			"ImportPath": "github.com/prometheus/client_golang/prometheus/promhttp",
+			"Rev": "e7e903064f5e9eb5da98208bae10b475d4db0f8c"
+		},
 		{
 			"ImportPath": "github.com/prometheus/client_model/go",
 			"Rev": "fa8ad6fec33561be4280a8f0514318c79d7f6cb6"
@@ -618,6 +626,10 @@
 			"ImportPath": "github.com/sirupsen/logrus",
 			"Rev": "89742aefa4b206dcf400792f3bd35b542998eb3b"
 		},
+		{
+			"ImportPath": "github.com/soheilhy/cmux",
+			"Rev": "bb79a83465015a27a175925ebd155e660f55e9f1"
+		},
 		{
 			"ImportPath": "github.com/spf13/cobra",
 			"Rev": "c439c4fa093711d42e1b01acb1235b52004753c1"
@@ -634,9 +646,13 @@
 			"ImportPath": "github.com/stretchr/testify/require",
 			"Rev": "c679ae2cc0cb27ec3293fea7e254e47386f05d69"
 		},
+		{
+			"ImportPath": "github.com/tmc/grpc-websocket-proxy/wsproxy",
+			"Rev": "89b8d40f7ca833297db804fcb3be53a76d01c238"
+		},
 		{
 			"ImportPath": "github.com/ugorji/go/codec",
-			"Rev": "ded73eae5db7e7a0ef6f55aace87a2873c5d2b74"
+			"Rev": "bdcc60b419d136a85cdf2e7cbcac34b3f1cd6e57"
 		},
 		{
 			"ImportPath": "github.com/xiang90/probing",
@@ -750,10 +766,6 @@
 			"ImportPath": "golang.org/x/time/rate",
 			"Rev": "f51c12702a4d776e4c1fa9b0fabab841babae631"
 		},
-		{
-			"ImportPath": "google.golang.org/genproto/googleapis/api/annotations",
-			"Rev": "09f6ed296fc66555a25fe4ce95173148778dfa85"
-		},
 		{
 			"ImportPath": "google.golang.org/genproto/googleapis/rpc/status",
 			"Rev": "09f6ed296fc66555a25fe4ce95173148778dfa85"
@@ -786,6 +798,10 @@
 			"ImportPath": "google.golang.org/grpc/grpclog",
 			"Rev": "5b3c4e850e90a4cf6a20ebd46c8b32a0a3afcb9e"
 		},
+		{
+			"ImportPath": "google.golang.org/grpc/health",
+			"Rev": "5b3c4e850e90a4cf6a20ebd46c8b32a0a3afcb9e"
+		},
 		{
 			"ImportPath": "google.golang.org/grpc/health/grpc_health_v1",
 			"Rev": "5b3c4e850e90a4cf6a20ebd46c8b32a0a3afcb9e"
diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go
index c771e61cb57..7649c78de27 100644
--- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -51,6 +50,7 @@ import fmt "fmt"
 import math "math"
 
 import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
+import encoding_binary "encoding/binary"
 
 import strings "strings"
 import reflect "reflect"
@@ -810,7 +810,8 @@ func (m *JSONSchemaProps) MarshalTo(dAtA []byte) (int, error) {
 	if m.Maximum != nil {
 		dAtA[i] = 0x49
 		i++
-		i = encodeFixed64Generated(dAtA, i, uint64(math.Float64bits(float64(*m.Maximum))))
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Maximum))))
+		i += 8
 	}
 	dAtA[i] = 0x50
 	i++
@@ -823,7 +824,8 @@ func (m *JSONSchemaProps) MarshalTo(dAtA []byte) (int, error) {
 	if m.Minimum != nil {
 		dAtA[i] = 0x59
 		i++
-		i = encodeFixed64Generated(dAtA, i, uint64(math.Float64bits(float64(*m.Minimum))))
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Minimum))))
+		i += 8
 	}
 	dAtA[i] = 0x60
 	i++
@@ -876,7 +878,8 @@ func (m *JSONSchemaProps) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		dAtA[i] = 0x1
 		i++
-		i = encodeFixed64Generated(dAtA, i, uint64(math.Float64bits(float64(*m.MultipleOf))))
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.MultipleOf))))
+		i += 8
 	}
 	if len(m.Enum) > 0 {
 		for _, msg := range m.Enum {
@@ -1291,24 +1294,6 @@ func (m *JSONSchemaPropsOrStringArray) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -4321,15 +4306,8 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 			if (iNdEx + 8) > l {
 				return io.ErrUnexpectedEOF
 			}
+			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
 			iNdEx += 8
-			v = uint64(dAtA[iNdEx-8])
-			v |= uint64(dAtA[iNdEx-7]) << 8
-			v |= uint64(dAtA[iNdEx-6]) << 16
-			v |= uint64(dAtA[iNdEx-5]) << 24
-			v |= uint64(dAtA[iNdEx-4]) << 32
-			v |= uint64(dAtA[iNdEx-3]) << 40
-			v |= uint64(dAtA[iNdEx-2]) << 48
-			v |= uint64(dAtA[iNdEx-1]) << 56
 			v2 := float64(math.Float64frombits(v))
 			m.Maximum = &v2
 		case 10:
@@ -4360,15 +4338,8 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 			if (iNdEx + 8) > l {
 				return io.ErrUnexpectedEOF
 			}
+			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
 			iNdEx += 8
-			v = uint64(dAtA[iNdEx-8])
-			v |= uint64(dAtA[iNdEx-7]) << 8
-			v |= uint64(dAtA[iNdEx-6]) << 16
-			v |= uint64(dAtA[iNdEx-5]) << 24
-			v |= uint64(dAtA[iNdEx-4]) << 32
-			v |= uint64(dAtA[iNdEx-3]) << 40
-			v |= uint64(dAtA[iNdEx-2]) << 48
-			v |= uint64(dAtA[iNdEx-1]) << 56
 			v2 := float64(math.Float64frombits(v))
 			m.Minimum = &v2
 		case 12:
@@ -4528,15 +4499,8 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 			if (iNdEx + 8) > l {
 				return io.ErrUnexpectedEOF
 			}
+			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
 			iNdEx += 8
-			v = uint64(dAtA[iNdEx-8])
-			v |= uint64(dAtA[iNdEx-7]) << 8
-			v |= uint64(dAtA[iNdEx-6]) << 16
-			v |= uint64(dAtA[iNdEx-5]) << 24
-			v |= uint64(dAtA[iNdEx-4]) << 32
-			v |= uint64(dAtA[iNdEx-3]) << 40
-			v |= uint64(dAtA[iNdEx-2]) << 48
-			v |= uint64(dAtA[iNdEx-1]) << 56
 			v2 := float64(math.Float64frombits(v))
 			m.MultipleOf = &v2
 		case 20:
@@ -4824,51 +4788,14 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Properties == nil {
 				m.Properties = make(map[string]JSONSchemaProps)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := &JSONSchemaProps{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -4878,46 +4805,85 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &JSONSchemaProps{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &JSONSchemaProps{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Properties[mapkey] = *mapvalue
-			} else {
-				var mapvalue JSONSchemaProps
-				m.Properties[mapkey] = mapvalue
 			}
+			m.Properties[mapkey] = *mapvalue
 			iNdEx = postIndex
 		case 30:
 			if wireType != 2 {
@@ -4978,51 +4944,14 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.PatternProperties == nil {
 				m.PatternProperties = make(map[string]JSONSchemaProps)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := &JSONSchemaProps{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -5032,46 +4961,85 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &JSONSchemaProps{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &JSONSchemaProps{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.PatternProperties[mapkey] = *mapvalue
-			} else {
-				var mapvalue JSONSchemaProps
-				m.PatternProperties[mapkey] = mapvalue
 			}
+			m.PatternProperties[mapkey] = *mapvalue
 			iNdEx = postIndex
 		case 32:
 			if wireType != 2 {
@@ -5099,51 +5067,14 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Dependencies == nil {
 				m.Dependencies = make(JSONSchemaDependencies)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := &JSONSchemaPropsOrStringArray{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -5153,46 +5084,85 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &JSONSchemaPropsOrStringArray{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &JSONSchemaPropsOrStringArray{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Dependencies[mapkey] = *mapvalue
-			} else {
-				var mapvalue JSONSchemaPropsOrStringArray
-				m.Dependencies[mapkey] = mapvalue
 			}
+			m.Dependencies[mapkey] = *mapvalue
 			iNdEx = postIndex
 		case 33:
 			if wireType != 2 {
@@ -5253,51 +5223,14 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Definitions == nil {
 				m.Definitions = make(JSONSchemaDefinitions)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			mapvalue := &JSONSchemaProps{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -5307,46 +5240,85 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &JSONSchemaProps{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &JSONSchemaProps{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Definitions[mapkey] = *mapvalue
-			} else {
-				var mapvalue JSONSchemaProps
-				m.Definitions[mapkey] = mapvalue
 			}
+			m.Definitions[mapkey] = *mapvalue
 			iNdEx = postIndex
 		case 35:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/apimachinery/Godeps/Godeps.json b/staging/src/k8s.io/apimachinery/Godeps/Godeps.json
index ab975f4fda3..3785b798b06 100644
--- a/staging/src/k8s.io/apimachinery/Godeps/Godeps.json
+++ b/staging/src/k8s.io/apimachinery/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/apimachinery",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -32,11 +32,11 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/apimachinery/pkg/api/resource/generated.pb.go b/staging/src/k8s.io/apimachinery/pkg/api/resource/generated.pb.go
index 802f22a63f3..9d7835bc23f 100644
--- a/staging/src/k8s.io/apimachinery/pkg/api/resource/generated.pb.go
+++ b/staging/src/k8s.io/apimachinery/pkg/api/resource/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/api/resource/generated.proto
-// DO NOT EDIT!
 
 /*
 Package resource is a generated protocol buffer package.
diff --git a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/generated.pb.go b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/generated.pb.go
index b7508f033e3..81320c9c882 100644
--- a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/generated.pb.go
+++ b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -1768,24 +1767,6 @@ func (m *WatchEvent) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -5043,51 +5024,14 @@ func (m *LabelSelector) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.MatchLabels == nil {
 				m.MatchLabels = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -5097,41 +5041,80 @@ func (m *LabelSelector) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.MatchLabels[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.MatchLabels[mapkey] = mapvalue
 			}
+			m.MatchLabels[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -6146,51 +6129,14 @@ func (m *ObjectMeta) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Labels == nil {
 				m.Labels = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -6200,41 +6146,80 @@ func (m *ObjectMeta) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Labels[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Labels[mapkey] = mapvalue
 			}
+			m.Labels[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 12:
 			if wireType != 2 {
@@ -6262,51 +6247,14 @@ func (m *ObjectMeta) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -6316,41 +6264,80 @@ func (m *ObjectMeta) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 13:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1beta1/generated.pb.go b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1beta1/generated.pb.go
index fe3df6916b0..47c03d69b96 100644
--- a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -148,24 +147,6 @@ func (m *TableOptions) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/apimachinery/pkg/apis/testapigroup/v1/generated.pb.go b/staging/src/k8s.io/apimachinery/pkg/apis/testapigroup/v1/generated.pb.go
index 5fd3c3f9753..b4960f4dbeb 100644
--- a/staging/src/k8s.io/apimachinery/pkg/apis/testapigroup/v1/generated.pb.go
+++ b/staging/src/k8s.io/apimachinery/pkg/apis/testapigroup/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/testapigroup/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -382,24 +381,6 @@ func (m *CarpStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1224,51 +1205,14 @@ func (m *CarpSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.NodeSelector == nil {
 				m.NodeSelector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1278,41 +1222,80 @@ func (m *CarpSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.NodeSelector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.NodeSelector[mapkey] = mapvalue
 			}
+			m.NodeSelector[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 8:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/apimachinery/pkg/runtime/generated.pb.go b/staging/src/k8s.io/apimachinery/pkg/runtime/generated.pb.go
index 967e0f530a3..9b15989c827 100644
--- a/staging/src/k8s.io/apimachinery/pkg/runtime/generated.pb.go
+++ b/staging/src/k8s.io/apimachinery/pkg/runtime/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package runtime is a generated protocol buffer package.
@@ -158,24 +157,6 @@ func (m *Unknown) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/apimachinery/pkg/runtime/schema/generated.pb.go b/staging/src/k8s.io/apimachinery/pkg/runtime/schema/generated.pb.go
index 5c9934c7399..28a61d5fb57 100644
--- a/staging/src/k8s.io/apimachinery/pkg/runtime/schema/generated.pb.go
+++ b/staging/src/k8s.io/apimachinery/pkg/runtime/schema/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto
-// DO NOT EDIT!
 
 /*
 Package schema is a generated protocol buffer package.
diff --git a/staging/src/k8s.io/apimachinery/pkg/util/intstr/generated.pb.go b/staging/src/k8s.io/apimachinery/pkg/util/intstr/generated.pb.go
index 5c2ac4f23fd..48dd7d9c551 100644
--- a/staging/src/k8s.io/apimachinery/pkg/util/intstr/generated.pb.go
+++ b/staging/src/k8s.io/apimachinery/pkg/util/intstr/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/util/intstr/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package intstr is a generated protocol buffer package.
@@ -81,24 +80,6 @@ func (m *IntOrString) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/apiserver/Godeps/Godeps.json b/staging/src/k8s.io/apiserver/Godeps/Godeps.json
index c7a233e6374..cc5e4022323 100644
--- a/staging/src/k8s.io/apiserver/Godeps/Godeps.json
+++ b/staging/src/k8s.io/apiserver/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/apiserver",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -34,305 +34,301 @@
 			"ImportPath": "github.com/beorn7/perks/quantile",
 			"Rev": "3ac7bf7a47d159a033b107610db8a1b6575507a4"
 		},
-		{
-			"ImportPath": "github.com/cockroachdb/cmux",
-			"Rev": "112f0506e7743d64a6eb8fedbcff13d9979bbf92"
-		},
 		{
 			"ImportPath": "github.com/coreos/bbolt",
 			"Rev": "48ea1b39c25fc1bab3506fbc712ecbaa842c4d2d"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/alarm",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/auth",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/auth/authpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/client",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3/concurrency",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3/namespace",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3/naming",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/compactor",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/discovery",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/embed",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/error",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/etcdhttp",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v2http",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v2http/httptypes",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
+		},
+		{
+			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v2v3",
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3client",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3election",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/gw",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3lock",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/gw",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3rpc",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/auth",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/etcdserverpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/etcdserverpb/gw",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/membership",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/stats",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/integration",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/lease",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/lease/leasehttp",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/lease/leasepb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc/backend",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc/mvccpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/adt",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/contention",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/cors",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/cpuutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/crc",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/debugutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/fileutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/httputil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/idutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/ioutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/logutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
-		},
-		{
-			"ImportPath": "github.com/coreos/etcd/pkg/monotime",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/netutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/pathutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/pbutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/runtime",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/schedule",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/srv",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/testutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/tlsutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/transport",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/types",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/wait",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/proxy/grpcproxy",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/proxy/grpcproxy/adapter",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/proxy/grpcproxy/cache",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/raft",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/raft/raftpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/rafthttp",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/snap",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/snap/snappb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/store",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/version",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/wal",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/wal/walpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc",
@@ -410,13 +406,21 @@
 			"ImportPath": "github.com/go-openapi/swag",
 			"Rev": "f3f9494671f93fcff853e3c6e9e948b3eb71e590"
 		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/gogoproto",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/descriptor",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
@@ -434,10 +438,6 @@
 			"ImportPath": "github.com/golang/protobuf/proto",
 			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
 		},
-		{
-			"ImportPath": "github.com/golang/protobuf/protoc-gen-go/descriptor",
-			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
-		},
 		{
 			"ImportPath": "github.com/golang/protobuf/ptypes",
 			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
@@ -478,6 +478,10 @@
 			"ImportPath": "github.com/googleapis/gnostic/extensions",
 			"Rev": "0c5108395e2debce0d731cf0287ddf7242066aba"
 		},
+		{
+			"ImportPath": "github.com/gorilla/websocket",
+			"Rev": "4201258b820c74ac8e6922fc9e6b52f71fe46f8d"
+		},
 		{
 			"ImportPath": "github.com/gregjones/httpcache",
 			"Rev": "787624de3eb7bd915c329cba748687a3b22666a6"
@@ -570,6 +574,10 @@
 			"ImportPath": "github.com/prometheus/client_golang/prometheus",
 			"Rev": "e7e903064f5e9eb5da98208bae10b475d4db0f8c"
 		},
+		{
+			"ImportPath": "github.com/prometheus/client_golang/prometheus/promhttp",
+			"Rev": "e7e903064f5e9eb5da98208bae10b475d4db0f8c"
+		},
 		{
 			"ImportPath": "github.com/prometheus/client_model/go",
 			"Rev": "fa8ad6fec33561be4280a8f0514318c79d7f6cb6"
@@ -598,6 +606,10 @@
 			"ImportPath": "github.com/sirupsen/logrus",
 			"Rev": "89742aefa4b206dcf400792f3bd35b542998eb3b"
 		},
+		{
+			"ImportPath": "github.com/soheilhy/cmux",
+			"Rev": "bb79a83465015a27a175925ebd155e660f55e9f1"
+		},
 		{
 			"ImportPath": "github.com/spf13/pflag",
 			"Rev": "583c0c0531f06d5278b7d917446061adc344b5cd"
@@ -610,9 +622,13 @@
 			"ImportPath": "github.com/stretchr/testify/require",
 			"Rev": "c679ae2cc0cb27ec3293fea7e254e47386f05d69"
 		},
+		{
+			"ImportPath": "github.com/tmc/grpc-websocket-proxy/wsproxy",
+			"Rev": "89b8d40f7ca833297db804fcb3be53a76d01c238"
+		},
 		{
 			"ImportPath": "github.com/ugorji/go/codec",
-			"Rev": "ded73eae5db7e7a0ef6f55aace87a2873c5d2b74"
+			"Rev": "bdcc60b419d136a85cdf2e7cbcac34b3f1cd6e57"
 		},
 		{
 			"ImportPath": "github.com/xiang90/probing",
@@ -758,10 +774,6 @@
 			"ImportPath": "golang.org/x/time/rate",
 			"Rev": "f51c12702a4d776e4c1fa9b0fabab841babae631"
 		},
-		{
-			"ImportPath": "google.golang.org/genproto/googleapis/api/annotations",
-			"Rev": "09f6ed296fc66555a25fe4ce95173148778dfa85"
-		},
 		{
 			"ImportPath": "google.golang.org/genproto/googleapis/rpc/status",
 			"Rev": "09f6ed296fc66555a25fe4ce95173148778dfa85"
@@ -794,6 +806,10 @@
 			"ImportPath": "google.golang.org/grpc/grpclog",
 			"Rev": "5b3c4e850e90a4cf6a20ebd46c8b32a0a3afcb9e"
 		},
+		{
+			"ImportPath": "google.golang.org/grpc/health",
+			"Rev": "5b3c4e850e90a4cf6a20ebd46c8b32a0a3afcb9e"
+		},
 		{
 			"ImportPath": "google.golang.org/grpc/health/grpc_health_v1",
 			"Rev": "5b3c4e850e90a4cf6a20ebd46c8b32a0a3afcb9e"
diff --git a/staging/src/k8s.io/apiserver/pkg/apis/audit/v1/generated.pb.go b/staging/src/k8s.io/apiserver/pkg/apis/audit/v1/generated.pb.go
index 756ea30baa9..7d4ce7573df 100644
--- a/staging/src/k8s.io/apiserver/pkg/apis/audit/v1/generated.pb.go
+++ b/staging/src/k8s.io/apiserver/pkg/apis/audit/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apiserver/pkg/apis/audit/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -610,24 +609,6 @@ func (m *PolicyRule) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1455,51 +1436,14 @@ func (m *Event) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1509,41 +1453,80 @@ func (m *Event) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 16:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.pb.go b/staging/src/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.pb.go
index 73a993c25c3..6ef668a9d96 100644
--- a/staging/src/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.pb.go
+++ b/staging/src/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1alpha1 is a generated protocol buffer package.
@@ -626,24 +625,6 @@ func (m *PolicyRule) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1534,51 +1515,14 @@ func (m *Event) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1588,41 +1532,80 @@ func (m *Event) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 18:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.pb.go b/staging/src/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.pb.go
index 53d25d9c36f..ecc26c2e735 100644
--- a/staging/src/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -630,24 +629,6 @@ func (m *PolicyRule) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1541,51 +1522,14 @@ func (m *Event) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Annotations == nil {
 				m.Annotations = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1595,41 +1539,80 @@ func (m *Event) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.Annotations[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.Annotations[mapkey] = mapvalue
 			}
+			m.Annotations[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 18:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/apiserver/pkg/apis/example/v1/generated.pb.go b/staging/src/k8s.io/apiserver/pkg/apis/example/v1/generated.pb.go
index b2f517e5538..24cacbde69e 100644
--- a/staging/src/k8s.io/apiserver/pkg/apis/example/v1/generated.pb.go
+++ b/staging/src/k8s.io/apiserver/pkg/apis/example/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apiserver/pkg/apis/example/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -382,24 +381,6 @@ func (m *PodStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1224,51 +1205,14 @@ func (m *PodSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.NodeSelector == nil {
 				m.NodeSelector = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -1278,41 +1222,80 @@ func (m *PodSpec) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.NodeSelector[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.NodeSelector[mapkey] = mapvalue
 			}
+			m.NodeSelector[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 8:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/apiserver/pkg/apis/example2/v1/generated.pb.go b/staging/src/k8s.io/apiserver/pkg/apis/example2/v1/generated.pb.go
index f1b385b1dbc..67881798743 100644
--- a/staging/src/k8s.io/apiserver/pkg/apis/example2/v1/generated.pb.go
+++ b/staging/src/k8s.io/apiserver/pkg/apis/example2/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/apiserver/pkg/apis/example2/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -154,24 +153,6 @@ func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/apiserver/pkg/storage/etcd/testing/utils.go b/staging/src/k8s.io/apiserver/pkg/storage/etcd/testing/utils.go
index 65bce88b62e..d5a770d8640 100644
--- a/staging/src/k8s.io/apiserver/pkg/storage/etcd/testing/utils.go
+++ b/staging/src/k8s.io/apiserver/pkg/storage/etcd/testing/utils.go
@@ -189,7 +189,7 @@ func configureTestCluster(t *testing.T, name string, https bool) *EtcdTestServer
 // launch will attempt to start the etcd server
 func (m *EtcdTestServer) launch(t *testing.T) error {
 	var err error
-	if m.s, err = etcdserver.NewServer(&m.ServerConfig); err != nil {
+	if m.s, err = etcdserver.NewServer(m.ServerConfig); err != nil {
 		return fmt.Errorf("failed to initialize the etcd server: %v", err)
 	}
 	m.s.SyncTicker = time.NewTicker(500 * time.Millisecond)
diff --git a/staging/src/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/v1beta1/service.pb.go b/staging/src/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/v1beta1/service.pb.go
index 888a03fa143..60cefd4f0b4 100644
--- a/staging/src/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/v1beta1/service.pb.go
+++ b/staging/src/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/v1beta1/service.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: service.proto
-// DO NOT EDIT!
 
 /*
 Package v1beta1 is a generated protocol buffer package.
diff --git a/staging/src/k8s.io/cli-runtime/Godeps/Godeps.json b/staging/src/k8s.io/cli-runtime/Godeps/Godeps.json
index 170cc171518..e608d79054d 100644
--- a/staging/src/k8s.io/cli-runtime/Godeps/Godeps.json
+++ b/staging/src/k8s.io/cli-runtime/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/cli-runtime",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -20,11 +20,11 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/client-go/Godeps/Godeps.json b/staging/src/k8s.io/client-go/Godeps/Godeps.json
index 9076b4032cb..441abe38288 100644
--- a/staging/src/k8s.io/client-go/Godeps/Godeps.json
+++ b/staging/src/k8s.io/client-go/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/client-go",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -56,11 +56,11 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/cloud-provider/Godeps/Godeps.json b/staging/src/k8s.io/cloud-provider/Godeps/Godeps.json
index 34b9258880e..8609f7bc882 100644
--- a/staging/src/k8s.io/cloud-provider/Godeps/Godeps.json
+++ b/staging/src/k8s.io/cloud-provider/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/cloud-provider",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -16,11 +16,11 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/cluster-bootstrap/Godeps/Godeps.json b/staging/src/k8s.io/cluster-bootstrap/Godeps/Godeps.json
index 08b58b27855..fc536250ef9 100644
--- a/staging/src/k8s.io/cluster-bootstrap/Godeps/Godeps.json
+++ b/staging/src/k8s.io/cluster-bootstrap/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/cluster-bootstrap",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -8,13 +8,11 @@
 	"Deps": [
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Comment": "v0.4-3-gc0656edd",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/code-generator/Godeps/Godeps.json b/staging/src/k8s.io/code-generator/Godeps/Godeps.json
index affc13ced2b..e1d0011940d 100644
--- a/staging/src/k8s.io/code-generator/Godeps/Godeps.json
+++ b/staging/src/k8s.io/code-generator/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/code-generator",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -40,103 +40,103 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/gogoproto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/compare",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/defaultcheck",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/description",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/embedcheck",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/enumstringer",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/equal",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/face",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/gostring",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/marshalto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/oneofcheck",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/populate",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/size",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/stringer",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/testgen",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/union",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/plugin/unmarshal",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/descriptor",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/generator",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/grpc",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/plugin",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/vanity",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/vanity/command",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/csi-api/Godeps/Godeps.json b/staging/src/k8s.io/csi-api/Godeps/Godeps.json
index 81318ce2ace..3e805777c9c 100644
--- a/staging/src/k8s.io/csi-api/Godeps/Godeps.json
+++ b/staging/src/k8s.io/csi-api/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/csi-api",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -16,11 +16,11 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/kube-aggregator/Godeps/Godeps.json b/staging/src/k8s.io/kube-aggregator/Godeps/Godeps.json
index 0ea2b148616..4828723a9f4 100644
--- a/staging/src/k8s.io/kube-aggregator/Godeps/Godeps.json
+++ b/staging/src/k8s.io/kube-aggregator/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/kube-aggregator",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -36,35 +36,35 @@
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/auth/authpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/etcdserverpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc/mvccpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/tlsutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/transport",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/types",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-systemd/daemon",
@@ -130,13 +130,21 @@
 			"ImportPath": "github.com/go-openapi/swag",
 			"Rev": "f3f9494671f93fcff853e3c6e9e948b3eb71e590"
 		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/gogoproto",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/descriptor",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
@@ -146,10 +154,6 @@
 			"ImportPath": "github.com/golang/protobuf/proto",
 			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
 		},
-		{
-			"ImportPath": "github.com/golang/protobuf/protoc-gen-go/descriptor",
-			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
-		},
 		{
 			"ImportPath": "github.com/golang/protobuf/ptypes",
 			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
@@ -410,10 +414,6 @@
 			"ImportPath": "golang.org/x/time/rate",
 			"Rev": "f51c12702a4d776e4c1fa9b0fabab841babae631"
 		},
-		{
-			"ImportPath": "google.golang.org/genproto/googleapis/api/annotations",
-			"Rev": "09f6ed296fc66555a25fe4ce95173148778dfa85"
-		},
 		{
 			"ImportPath": "google.golang.org/genproto/googleapis/rpc/status",
 			"Rev": "09f6ed296fc66555a25fe4ce95173148778dfa85"
diff --git a/staging/src/k8s.io/kube-aggregator/pkg/apis/apiregistration/v1/generated.pb.go b/staging/src/k8s.io/kube-aggregator/pkg/apis/apiregistration/v1/generated.pb.go
index 593971a45c4..310ca7010b0 100644
--- a/staging/src/k8s.io/kube-aggregator/pkg/apis/apiregistration/v1/generated.pb.go
+++ b/staging/src/k8s.io/kube-aggregator/pkg/apis/apiregistration/v1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/kube-aggregator/pkg/apis/apiregistration/v1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1 is a generated protocol buffer package.
@@ -320,24 +319,6 @@ func (m *ServiceReference) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1/generated.pb.go b/staging/src/k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1/generated.pb.go
index c5e1a58042c..7c00be38be0 100644
--- a/staging/src/k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -320,24 +319,6 @@ func (m *ServiceReference) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/kube-controller-manager/Godeps/Godeps.json b/staging/src/k8s.io/kube-controller-manager/Godeps/Godeps.json
index 3085911b9d7..0d07751e86f 100644
--- a/staging/src/k8s.io/kube-controller-manager/Godeps/Godeps.json
+++ b/staging/src/k8s.io/kube-controller-manager/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/kube-controller-manager",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -8,11 +8,11 @@
 	"Deps": [
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/kube-proxy/Godeps/Godeps.json b/staging/src/k8s.io/kube-proxy/Godeps/Godeps.json
index 900d7f081cc..ff3e44acfaf 100644
--- a/staging/src/k8s.io/kube-proxy/Godeps/Godeps.json
+++ b/staging/src/k8s.io/kube-proxy/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/kube-proxy",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -8,11 +8,11 @@
 	"Deps": [
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/kube-scheduler/Godeps/Godeps.json b/staging/src/k8s.io/kube-scheduler/Godeps/Godeps.json
index 4237b68ffbe..ff61f39417f 100644
--- a/staging/src/k8s.io/kube-scheduler/Godeps/Godeps.json
+++ b/staging/src/k8s.io/kube-scheduler/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/kube-scheduler",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -8,11 +8,11 @@
 	"Deps": [
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/kubelet/Godeps/Godeps.json b/staging/src/k8s.io/kubelet/Godeps/Godeps.json
index fab239cf623..dbf0ed89d3d 100644
--- a/staging/src/k8s.io/kubelet/Godeps/Godeps.json
+++ b/staging/src/k8s.io/kubelet/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/kubelet",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -8,11 +8,11 @@
 	"Deps": [
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/metrics/Godeps/Godeps.json b/staging/src/k8s.io/metrics/Godeps/Godeps.json
index b764ae31114..0b724c72b1c 100644
--- a/staging/src/k8s.io/metrics/Godeps/Godeps.json
+++ b/staging/src/k8s.io/metrics/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/metrics",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -16,11 +16,11 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1/generated.pb.go b/staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1/generated.pb.go
index 704c8cc6345..7f4fa287de1 100644
--- a/staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -195,24 +194,6 @@ func (m *MetricValueList) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta2/generated.pb.go b/staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta2/generated.pb.go
index d0b3e2af6ae..b81302ada7b 100644
--- a/staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta2/generated.pb.go
+++ b/staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta2/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/metrics/pkg/apis/custom_metrics/v1beta2/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta2 is a generated protocol buffer package.
@@ -227,24 +226,6 @@ func (m *MetricValueList) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.pb.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.pb.go
index f5d3f0eab20..a15750765c7 100644
--- a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -167,24 +166,6 @@ func (m *ExternalMetricValueList) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -371,51 +352,14 @@ func (m *ExternalMetricValue) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.MetricLabels == nil {
 				m.MetricLabels = make(map[string]string)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -425,41 +369,80 @@ func (m *ExternalMetricValue) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var stringLenmapvalue uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				intStringLenmapvalue := int(stringLenmapvalue)
-				if intStringLenmapvalue < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-				if postStringIndexmapvalue > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
-				iNdEx = postStringIndexmapvalue
-				m.MetricLabels[mapkey] = mapvalue
-			} else {
-				var mapvalue string
-				m.MetricLabels[mapkey] = mapvalue
 			}
+			m.MetricLabels[mapkey] = mapvalue
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
diff --git a/staging/src/k8s.io/metrics/pkg/apis/metrics/v1alpha1/generated.pb.go b/staging/src/k8s.io/metrics/pkg/apis/metrics/v1alpha1/generated.pb.go
index 6bd8967b402..3c6b4b4182c 100644
--- a/staging/src/k8s.io/metrics/pkg/apis/metrics/v1alpha1/generated.pb.go
+++ b/staging/src/k8s.io/metrics/pkg/apis/metrics/v1alpha1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/metrics/pkg/apis/metrics/v1alpha1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1alpha1 is a generated protocol buffer package.
@@ -342,24 +341,6 @@ func (m *PodMetricsList) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -637,51 +618,14 @@ func (m *ContainerMetrics) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Usage == nil {
 				m.Usage = make(k8s_io_api_core_v1.ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey k8s_io_api_core_v1.ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -691,46 +635,85 @@ func (m *ContainerMetrics) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = mapvalue
 			}
+			m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -898,51 +881,14 @@ func (m *NodeMetrics) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Usage == nil {
 				m.Usage = make(k8s_io_api_core_v1.ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey k8s_io_api_core_v1.ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -952,46 +898,85 @@ func (m *NodeMetrics) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = mapvalue
 			}
+			m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/staging/src/k8s.io/metrics/pkg/apis/metrics/v1beta1/generated.pb.go b/staging/src/k8s.io/metrics/pkg/apis/metrics/v1beta1/generated.pb.go
index 4d287a29ec8..d2166bfe557 100644
--- a/staging/src/k8s.io/metrics/pkg/apis/metrics/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/metrics/pkg/apis/metrics/v1beta1/generated.pb.go
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: k8s.io/kubernetes/vendor/k8s.io/metrics/pkg/apis/metrics/v1beta1/generated.proto
-// DO NOT EDIT!
 
 /*
 	Package v1beta1 is a generated protocol buffer package.
@@ -342,24 +341,6 @@ func (m *PodMetricsList) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -637,51 +618,14 @@ func (m *ContainerMetrics) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Usage == nil {
 				m.Usage = make(k8s_io_api_core_v1.ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey k8s_io_api_core_v1.ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -691,46 +635,85 @@ func (m *ContainerMetrics) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = mapvalue
 			}
+			m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -898,51 +881,14 @@ func (m *NodeMetrics) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Usage == nil {
 				m.Usage = make(k8s_io_api_core_v1.ResourceList)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey k8s_io_api_core_v1.ResourceName
+			mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowGenerated
@@ -952,46 +898,85 @@ func (m *NodeMetrics) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowGenerated
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthGenerated
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &k8s_io_apimachinery_pkg_api_resource.Quantity{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = *mapvalue
-			} else {
-				var mapvalue k8s_io_apimachinery_pkg_api_resource.Quantity
-				m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = mapvalue
 			}
+			m.Usage[k8s_io_api_core_v1.ResourceName(mapkey)] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/staging/src/k8s.io/sample-apiserver/Godeps/Godeps.json b/staging/src/k8s.io/sample-apiserver/Godeps/Godeps.json
index 4daa77c9b6d..a25db2255a8 100644
--- a/staging/src/k8s.io/sample-apiserver/Godeps/Godeps.json
+++ b/staging/src/k8s.io/sample-apiserver/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/sample-apiserver",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -36,35 +36,35 @@
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/auth/authpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/clientv3",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/etcdserver/etcdserverpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/mvcc/mvccpb",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/tlsutil",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/transport",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/etcd/pkg/types",
-			"Rev": "420a452267a7ce45b3fcbed04d54030d69964fc1"
+			"Rev": "fca8add78a9d926166eb739b8e4a124434025ba3"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-systemd/daemon",
@@ -122,13 +122,21 @@
 			"ImportPath": "github.com/go-openapi/swag",
 			"Rev": "f3f9494671f93fcff853e3c6e9e948b3eb71e590"
 		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/gogoproto",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/protoc-gen-gogo/descriptor",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
@@ -138,10 +146,6 @@
 			"ImportPath": "github.com/golang/protobuf/proto",
 			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
 		},
-		{
-			"ImportPath": "github.com/golang/protobuf/protoc-gen-go/descriptor",
-			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
-		},
 		{
 			"ImportPath": "github.com/golang/protobuf/ptypes",
 			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
@@ -382,10 +386,6 @@
 			"ImportPath": "golang.org/x/time/rate",
 			"Rev": "f51c12702a4d776e4c1fa9b0fabab841babae631"
 		},
-		{
-			"ImportPath": "google.golang.org/genproto/googleapis/api/annotations",
-			"Rev": "09f6ed296fc66555a25fe4ce95173148778dfa85"
-		},
 		{
 			"ImportPath": "google.golang.org/genproto/googleapis/rpc/status",
 			"Rev": "09f6ed296fc66555a25fe4ce95173148778dfa85"
diff --git a/staging/src/k8s.io/sample-cli-plugin/Godeps/Godeps.json b/staging/src/k8s.io/sample-cli-plugin/Godeps/Godeps.json
index 3b77611e6c0..c100b642fbc 100644
--- a/staging/src/k8s.io/sample-cli-plugin/Godeps/Godeps.json
+++ b/staging/src/k8s.io/sample-cli-plugin/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/sample-cli-plugin",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -16,11 +16,11 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/staging/src/k8s.io/sample-controller/Godeps/Godeps.json b/staging/src/k8s.io/sample-controller/Godeps/Godeps.json
index afe92d652a5..0e0cfc26f90 100644
--- a/staging/src/k8s.io/sample-controller/Godeps/Godeps.json
+++ b/staging/src/k8s.io/sample-controller/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/sample-controller",
-	"GoVersion": "go1.10",
+	"GoVersion": "go1.11",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -16,11 +16,11 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
diff --git a/vendor/BUILD b/vendor/BUILD
index 6e3992c2ad4..9039b2bdd89 100644
--- a/vendor/BUILD
+++ b/vendor/BUILD
@@ -91,7 +91,6 @@ filegroup(
         "//vendor/github.com/cloudflare/cfssl/signer:all-srcs",
         "//vendor/github.com/cloudflare/cfssl/ubiquity:all-srcs",
         "//vendor/github.com/clusterhq/flocker-go:all-srcs",
-        "//vendor/github.com/cockroachdb/cmux:all-srcs",
         "//vendor/github.com/codedellemc/goscaleio:all-srcs",
         "//vendor/github.com/container-storage-interface/spec/lib/go/csi/v0:all-srcs",
         "//vendor/github.com/containerd/console:all-srcs",
@@ -131,7 +130,6 @@ filegroup(
         "//vendor/github.com/coreos/etcd/pkg/idutil:all-srcs",
         "//vendor/github.com/coreos/etcd/pkg/ioutil:all-srcs",
         "//vendor/github.com/coreos/etcd/pkg/logutil:all-srcs",
-        "//vendor/github.com/coreos/etcd/pkg/monotime:all-srcs",
         "//vendor/github.com/coreos/etcd/pkg/netutil:all-srcs",
         "//vendor/github.com/coreos/etcd/pkg/pathutil:all-srcs",
         "//vendor/github.com/coreos/etcd/pkg/pbutil:all-srcs",
@@ -237,7 +235,6 @@ filegroup(
         "//vendor/github.com/golang/mock/gomock:all-srcs",
         "//vendor/github.com/golang/protobuf/jsonpb:all-srcs",
         "//vendor/github.com/golang/protobuf/proto:all-srcs",
-        "//vendor/github.com/golang/protobuf/protoc-gen-go/descriptor:all-srcs",
         "//vendor/github.com/golang/protobuf/ptypes:all-srcs",
         "//vendor/github.com/google/btree:all-srcs",
         "//vendor/github.com/google/cadvisor/accelerators:all-srcs",
@@ -347,6 +344,7 @@ filegroup(
         "//vendor/github.com/seccomp/libseccomp-golang:all-srcs",
         "//vendor/github.com/shurcooL/sanitized_anchor_name:all-srcs",
         "//vendor/github.com/sirupsen/logrus:all-srcs",
+        "//vendor/github.com/soheilhy/cmux:all-srcs",
         "//vendor/github.com/spf13/afero:all-srcs",
         "//vendor/github.com/spf13/cast:all-srcs",
         "//vendor/github.com/spf13/cobra:all-srcs",
@@ -359,6 +357,7 @@ filegroup(
         "//vendor/github.com/stretchr/testify/mock:all-srcs",
         "//vendor/github.com/stretchr/testify/require:all-srcs",
         "//vendor/github.com/syndtr/gocapability/capability:all-srcs",
+        "//vendor/github.com/tmc/grpc-websocket-proxy/wsproxy:all-srcs",
         "//vendor/github.com/tools/godep:all-srcs",
         "//vendor/github.com/ugorji/go/codec:all-srcs",
         "//vendor/github.com/vishvananda/netlink:all-srcs",
@@ -430,7 +429,6 @@ filegroup(
         "//vendor/google.golang.org/api/monitoring/v3:all-srcs",
         "//vendor/google.golang.org/api/pubsub/v1:all-srcs",
         "//vendor/google.golang.org/api/tpu/v1:all-srcs",
-        "//vendor/google.golang.org/genproto/googleapis/api/annotations:all-srcs",
         "//vendor/google.golang.org/genproto/googleapis/rpc/status:all-srcs",
         "//vendor/google.golang.org/grpc:all-srcs",
         "//vendor/gopkg.in/gcfg.v1:all-srcs",
diff --git a/vendor/github.com/cockroachdb/cmux/.travis.yml b/vendor/github.com/cockroachdb/cmux/.travis.yml
deleted file mode 100644
index e73780f2eb0..00000000000
--- a/vendor/github.com/cockroachdb/cmux/.travis.yml
+++ /dev/null
@@ -1,22 +0,0 @@
-language: go
-
-go:
-  - 1.3
-  - 1.4
-  - 1.5
-  - 1.6
-
-gobuild_args: -race
-
-before_install:
-  - go get -u github.com/golang/lint/golint
-  - if [[ $TRAVIS_GO_VERSION == 1.5* ]]; then go get -u github.com/kisielk/errcheck; fi
-  - go get -u golang.org/x/tools/cmd/vet
-
-before_script:
-  - '! gofmt -s -l . | read'
-  - golint ./...
-  - echo $TRAVIS_GO_VERSION
-  - if [[ $TRAVIS_GO_VERSION == 1.5* ]]; then errcheck ./...; fi
-  - go vet .
-  - go tool vet --shadow .
diff --git a/vendor/github.com/cockroachdb/cmux/README.md b/vendor/github.com/cockroachdb/cmux/README.md
deleted file mode 100644
index b3713da5876..00000000000
--- a/vendor/github.com/cockroachdb/cmux/README.md
+++ /dev/null
@@ -1,65 +0,0 @@
-# cmux: Connection Mux [![Build Status](https://travis-ci.org/cockroachdb/cmux.svg?branch=master)](https://travis-ci.org/cockroachdb/cmux) [![GoDoc](https://godoc.org/github.com/cockroachdb/cmux?status.svg)](https://godoc.org/github.com/cockroachdb/cmux)
-
-cmux is a generic Go library to multiplex connections based on their payload.
-Using cmux, you can serve gRPC, SSH, HTTPS, HTTP, Go RPC, and pretty much any
-other protocol on the same TCP listener.
-
-## How-To
-Simply create your main listener, create a cmux for that listener,
-and then match connections:
-```go
-// Create the main listener.
-l, err := net.Listen("tcp", ":23456")
-if err != nil {
-	log.Fatal(err)
-}
-
-// Create a cmux.
-m := cmux.New(l)
-
-// Match connections in order:
-// First grpc, then HTTP, and otherwise Go RPC/TCP.
-grpcL := m.Match(cmux.HTTP2HeaderField("content-type", "application/grpc"))
-httpL := m.Match(cmux.HTTP1Fast())
-trpcL := m.Match(cmux.Any()) // Any means anything that is not yet matched.
-
-// Create your protocol servers.
-grpcS := grpc.NewServer()
-grpchello.RegisterGreeterServer(grpcs, &server{})
-
-httpS := &http.Server{
-	Handler: &helloHTTP1Handler{},
-}
-
-trpcS := rpc.NewServer()
-s.Register(&ExampleRPCRcvr{})
-
-// Use the muxed listeners for your servers.
-go grpcS.Serve(grpcL)
-go httpS.Serve(httpL)
-go trpcS.Accept(trpcL)
-
-// Start serving!
-m.Serve()
-```
-
-There are [more examples on GoDoc](https://godoc.org/github.com/cockroachdb/cmux#pkg-examples).
-
-## Performance
-Since we are only matching the very first bytes of a connection, the
-performance overhead on long-lived connections (i.e., RPCs and pipelined HTTP
-streams) is negligible.
-
-## Limitations
-* *TLS*: `net/http` uses a [type assertion](https://github.com/golang/go/issues/14221)
-to identify TLS connections; since cmux's lookahead-implementing connection
-wraps the underlying TLS connection, this type assertion fails. This means you
-can serve HTTPS using cmux but `http.Request.TLS` will not be set in your
-handlers. If you are able to wrap TLS around cmux, you can work around this
-limitation. See https://github.com/cockroachdb/cockroach/commit/83caba2 for an
-example of this approach.
-
-* *Different Protocols on The Same Connection*: `cmux` matches the connection
-when it's accepted. For example, one connection can be either gRPC or REST, but
-not both. That is, we assume that a client connection is either used for gRPC
-or REST.
diff --git a/vendor/github.com/cockroachdb/cmux/buffer.go b/vendor/github.com/cockroachdb/cmux/buffer.go
deleted file mode 100644
index 5c178585363..00000000000
--- a/vendor/github.com/cockroachdb/cmux/buffer.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package cmux
-
-import (
-	"bytes"
-	"io"
-)
-
-// bufferedReader is an optimized implementation of io.Reader that behaves like
-// ```
-// io.MultiReader(bytes.NewReader(buffer.Bytes()), io.TeeReader(source, buffer))
-// ```
-// without allocating.
-type bufferedReader struct {
-	source     io.Reader
-	buffer     *bytes.Buffer
-	bufferRead int
-	bufferSize int
-}
-
-func (s *bufferedReader) Read(p []byte) (int, error) {
-	// Functionality of bytes.Reader.
-	bn := copy(p, s.buffer.Bytes()[s.bufferRead:s.bufferSize])
-	s.bufferRead += bn
-
-	p = p[bn:]
-
-	// Funtionality of io.TeeReader.
-	sn, sErr := s.source.Read(p)
-	if sn > 0 {
-		if wn, wErr := s.buffer.Write(p[:sn]); wErr != nil {
-			return bn + wn, wErr
-		}
-	}
-	return bn + sn, sErr
-}
diff --git a/vendor/github.com/cockroachdb/cmux/matchers.go b/vendor/github.com/cockroachdb/cmux/matchers.go
deleted file mode 100644
index abc30f6e0ad..00000000000
--- a/vendor/github.com/cockroachdb/cmux/matchers.go
+++ /dev/null
@@ -1,150 +0,0 @@
-package cmux
-
-import (
-	"bufio"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"strings"
-
-	"golang.org/x/net/http2"
-	"golang.org/x/net/http2/hpack"
-)
-
-// Any is a Matcher that matches any connection.
-func Any() Matcher {
-	return func(r io.Reader) bool { return true }
-}
-
-// PrefixMatcher returns a matcher that matches a connection if it
-// starts with any of the strings in strs.
-func PrefixMatcher(strs ...string) Matcher {
-	pt := newPatriciaTreeString(strs...)
-	return pt.matchPrefix
-}
-
-var defaultHTTPMethods = []string{
-	"OPTIONS",
-	"GET",
-	"HEAD",
-	"POST",
-	"PUT",
-	"DELETE",
-	"TRACE",
-	"CONNECT",
-}
-
-// HTTP1Fast only matches the methods in the HTTP request.
-//
-// This matcher is very optimistic: if it returns true, it does not mean that
-// the request is a valid HTTP response. If you want a correct but slower HTTP1
-// matcher, use HTTP1 instead.
-func HTTP1Fast(extMethods ...string) Matcher {
-	return PrefixMatcher(append(defaultHTTPMethods, extMethods...)...)
-}
-
-const maxHTTPRead = 4096
-
-// HTTP1 parses the first line or upto 4096 bytes of the request to see if
-// the conection contains an HTTP request.
-func HTTP1() Matcher {
-	return func(r io.Reader) bool {
-		br := bufio.NewReader(&io.LimitedReader{R: r, N: maxHTTPRead})
-		l, part, err := br.ReadLine()
-		if err != nil || part {
-			return false
-		}
-
-		_, _, proto, ok := parseRequestLine(string(l))
-		if !ok {
-			return false
-		}
-
-		v, _, ok := http.ParseHTTPVersion(proto)
-		return ok && v == 1
-	}
-}
-
-// grabbed from net/http.
-func parseRequestLine(line string) (method, uri, proto string, ok bool) {
-	s1 := strings.Index(line, " ")
-	s2 := strings.Index(line[s1+1:], " ")
-	if s1 < 0 || s2 < 0 {
-		return
-	}
-	s2 += s1 + 1
-	return line[:s1], line[s1+1 : s2], line[s2+1:], true
-}
-
-// HTTP2 parses the frame header of the first frame to detect whether the
-// connection is an HTTP2 connection.
-func HTTP2() Matcher {
-	return hasHTTP2Preface
-}
-
-// HTTP1HeaderField returns a matcher matching the header fields of the first
-// request of an HTTP 1 connection.
-func HTTP1HeaderField(name, value string) Matcher {
-	return func(r io.Reader) bool {
-		return matchHTTP1Field(r, name, value)
-	}
-}
-
-// HTTP2HeaderField resturns a matcher matching the header fields of the first
-// headers frame.
-func HTTP2HeaderField(name, value string) Matcher {
-	return func(r io.Reader) bool {
-		return matchHTTP2Field(r, name, value)
-	}
-}
-
-func hasHTTP2Preface(r io.Reader) bool {
-	var b [len(http2.ClientPreface)]byte
-	if _, err := io.ReadFull(r, b[:]); err != nil {
-		return false
-	}
-
-	return string(b[:]) == http2.ClientPreface
-}
-
-func matchHTTP1Field(r io.Reader, name, value string) (matched bool) {
-	req, err := http.ReadRequest(bufio.NewReader(r))
-	if err != nil {
-		return false
-	}
-
-	return req.Header.Get(name) == value
-}
-
-func matchHTTP2Field(r io.Reader, name, value string) (matched bool) {
-	if !hasHTTP2Preface(r) {
-		return false
-	}
-
-	framer := http2.NewFramer(ioutil.Discard, r)
-	hdec := hpack.NewDecoder(uint32(4<<10), func(hf hpack.HeaderField) {
-		if hf.Name == name && hf.Value == value {
-			matched = true
-		}
-	})
-	for {
-		f, err := framer.ReadFrame()
-		if err != nil {
-			return false
-		}
-
-		switch f := f.(type) {
-		case *http2.HeadersFrame:
-			if _, err := hdec.Write(f.HeaderBlockFragment()); err != nil {
-				return false
-			}
-			if matched {
-				return true
-			}
-
-			if f.FrameHeader.Flags&http2.FlagHeadersEndHeaders != 0 {
-				return false
-			}
-		}
-	}
-}
diff --git a/vendor/github.com/coreos/etcd/auth/BUILD b/vendor/github.com/coreos/etcd/auth/BUILD
index 8c9af9e4cc3..c13e0727e6a 100644
--- a/vendor/github.com/coreos/etcd/auth/BUILD
+++ b/vendor/github.com/coreos/etcd/auth/BUILD
@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "doc.go",
         "jwt.go",
+        "nop.go",
         "range_perm_cache.go",
         "simple_token.go",
         "store.go",
@@ -20,7 +21,6 @@ go_library(
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
         "//vendor/github.com/dgrijalva/jwt-go:go_default_library",
         "//vendor/golang.org/x/crypto/bcrypt:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
         "//vendor/google.golang.org/grpc/credentials:go_default_library",
         "//vendor/google.golang.org/grpc/metadata:go_default_library",
         "//vendor/google.golang.org/grpc/peer:go_default_library",
diff --git a/vendor/github.com/coreos/etcd/auth/authpb/BUILD b/vendor/github.com/coreos/etcd/auth/authpb/BUILD
index 88708176a5d..27e2c65ce22 100644
--- a/vendor/github.com/coreos/etcd/auth/authpb/BUILD
+++ b/vendor/github.com/coreos/etcd/auth/authpb/BUILD
@@ -6,7 +6,10 @@ go_library(
     importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/auth/authpb",
     importpath = "github.com/coreos/etcd/auth/authpb",
     visibility = ["//visibility:public"],
-    deps = ["//vendor/github.com/golang/protobuf/proto:go_default_library"],
+    deps = [
+        "//vendor/github.com/gogo/protobuf/gogoproto:go_default_library",
+        "//vendor/github.com/golang/protobuf/proto:go_default_library",
+    ],
 )
 
 filegroup(
diff --git a/vendor/github.com/coreos/etcd/auth/authpb/auth.pb.go b/vendor/github.com/coreos/etcd/auth/authpb/auth.pb.go
index 009ebda70ca..1a940c39b26 100644
--- a/vendor/github.com/coreos/etcd/auth/authpb/auth.pb.go
+++ b/vendor/github.com/coreos/etcd/auth/authpb/auth.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: auth.proto
-// DO NOT EDIT!
 
 /*
 	Package authpb is a generated protocol buffer package.
@@ -22,6 +21,8 @@ import (
 
 	math "math"
 
+	_ "github.com/gogo/protobuf/gogoproto"
+
 	io "io"
 )
 
@@ -217,24 +218,6 @@ func (m *Role) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Auth(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Auth(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintAuth(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/coreos/etcd/auth/jwt.go b/vendor/github.com/coreos/etcd/auth/jwt.go
index 214ae48c83a..99b2d6b5c71 100644
--- a/vendor/github.com/coreos/etcd/auth/jwt.go
+++ b/vendor/github.com/coreos/etcd/auth/jwt.go
@@ -15,11 +15,11 @@
 package auth
 
 import (
+	"context"
 	"crypto/rsa"
 	"io/ioutil"
 
 	jwt "github.com/dgrijalva/jwt-go"
-	"golang.org/x/net/context"
 )
 
 type tokenJWT struct {
@@ -97,7 +97,9 @@ func prepareOpts(opts map[string]string) (jwtSignMethod, jwtPubKeyPath, jwtPrivK
 			return "", "", "", ErrInvalidAuthOpts
 		}
 	}
-
+	if len(jwtSignMethod) == 0 {
+		return "", "", "", ErrInvalidAuthOpts
+	}
 	return jwtSignMethod, jwtPubKeyPath, jwtPrivKeyPath, nil
 }
 
diff --git a/vendor/github.com/coreos/etcd/auth/nop.go b/vendor/github.com/coreos/etcd/auth/nop.go
new file mode 100644
index 00000000000..d4378747bd8
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/auth/nop.go
@@ -0,0 +1,35 @@
+// Copyright 2018 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package auth
+
+import (
+	"context"
+)
+
+type tokenNop struct{}
+
+func (t *tokenNop) enable()                         {}
+func (t *tokenNop) disable()                        {}
+func (t *tokenNop) invalidateUser(string)           {}
+func (t *tokenNop) genTokenPrefix() (string, error) { return "", nil }
+func (t *tokenNop) info(ctx context.Context, token string, rev uint64) (*AuthInfo, bool) {
+	return nil, false
+}
+func (t *tokenNop) assign(ctx context.Context, username string, revision uint64) (string, error) {
+	return "", ErrAuthFailed
+}
+func newTokenProviderNop() (*tokenNop, error) {
+	return &tokenNop{}, nil
+}
diff --git a/vendor/github.com/coreos/etcd/auth/simple_token.go b/vendor/github.com/coreos/etcd/auth/simple_token.go
index 39e610f1577..ac55ad7f13f 100644
--- a/vendor/github.com/coreos/etcd/auth/simple_token.go
+++ b/vendor/github.com/coreos/etcd/auth/simple_token.go
@@ -18,6 +18,7 @@ package auth
 // JWT based mechanism will be added in the near future.
 
 import (
+	"context"
 	"crypto/rand"
 	"fmt"
 	"math/big"
@@ -25,8 +26,6 @@ import (
 	"strings"
 	"sync"
 	"time"
-
-	"golang.org/x/net/context"
 )
 
 const (
@@ -189,9 +188,9 @@ func (t *tokenSimple) info(ctx context.Context, token string, revision uint64) (
 
 func (t *tokenSimple) assign(ctx context.Context, username string, rev uint64) (string, error) {
 	// rev isn't used in simple token, it is only used in JWT
-	index := ctx.Value("index").(uint64)
-	simpleToken := ctx.Value("simpleToken").(string)
-	token := fmt.Sprintf("%s.%d", simpleToken, index)
+	index := ctx.Value(AuthenticateParamIndex{}).(uint64)
+	simpleTokenPrefix := ctx.Value(AuthenticateParamSimpleTokenPrefix{}).(string)
+	token := fmt.Sprintf("%s.%d", simpleTokenPrefix, index)
 	t.assignSimpleTokenToUser(username, token)
 
 	return token, nil
diff --git a/vendor/github.com/coreos/etcd/auth/store.go b/vendor/github.com/coreos/etcd/auth/store.go
index 3fac7f5a6fd..c2455a903bb 100644
--- a/vendor/github.com/coreos/etcd/auth/store.go
+++ b/vendor/github.com/coreos/etcd/auth/store.go
@@ -16,6 +16,7 @@ package auth
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"errors"
 	"sort"
@@ -26,9 +27,9 @@ import (
 	"github.com/coreos/etcd/auth/authpb"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/mvcc/backend"
+
 	"github.com/coreos/pkg/capnslog"
 	"golang.org/x/crypto/bcrypt"
-	"golang.org/x/net/context"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/peer"
@@ -72,6 +73,9 @@ const (
 	rootUser = "root"
 	rootRole = "root"
 
+	tokenTypeSimple = "simple"
+	tokenTypeJWT    = "jwt"
+
 	revBytesLen = 8
 )
 
@@ -80,6 +84,12 @@ type AuthInfo struct {
 	Revision uint64
 }
 
+// AuthenticateParamIndex is used for a key of context in the parameters of Authenticate()
+type AuthenticateParamIndex struct{}
+
+// AuthenticateParamSimpleTokenPrefix is used for a key of context in the parameters of Authenticate()
+type AuthenticateParamSimpleTokenPrefix struct{}
+
 type AuthStore interface {
 	// AuthEnable turns on the authentication feature
 	AuthEnable() error
@@ -162,6 +172,12 @@ type AuthStore interface {
 
 	// AuthInfoFromTLS gets AuthInfo from TLS info of gRPC's context
 	AuthInfoFromTLS(ctx context.Context) *AuthInfo
+
+	// WithRoot generates and installs a token that can be used as a root credential
+	WithRoot(ctx context.Context) context.Context
+
+	// HasRole checks that user has role
+	HasRole(user, role string) bool
 }
 
 type TokenProvider interface {
@@ -445,7 +461,7 @@ func (as *authStore) UserGrantRole(r *pb.AuthUserGrantRoleRequest) (*pb.AuthUser
 	}
 
 	user.Roles = append(user.Roles, r.Role)
-	sort.Sort(sort.StringSlice(user.Roles))
+	sort.Strings(user.Roles)
 
 	putUser(tx, user)
 
@@ -460,14 +476,14 @@ func (as *authStore) UserGrantRole(r *pb.AuthUserGrantRoleRequest) (*pb.AuthUser
 func (as *authStore) UserGet(r *pb.AuthUserGetRequest) (*pb.AuthUserGetResponse, error) {
 	tx := as.be.BatchTx()
 	tx.Lock()
-	defer tx.Unlock()
-
-	var resp pb.AuthUserGetResponse
-
 	user := getUser(tx, r.Name)
+	tx.Unlock()
+
 	if user == nil {
 		return nil, ErrUserNotFound
 	}
+
+	var resp pb.AuthUserGetResponse
 	resp.Roles = append(resp.Roles, user.Roles...)
 	return &resp, nil
 }
@@ -475,17 +491,14 @@ func (as *authStore) UserGet(r *pb.AuthUserGetRequest) (*pb.AuthUserGetResponse,
 func (as *authStore) UserList(r *pb.AuthUserListRequest) (*pb.AuthUserListResponse, error) {
 	tx := as.be.BatchTx()
 	tx.Lock()
-	defer tx.Unlock()
-
-	var resp pb.AuthUserListResponse
-
 	users := getAllUsers(tx)
+	tx.Unlock()
 
-	for _, u := range users {
-		resp.Users = append(resp.Users, string(u.Name))
+	resp := &pb.AuthUserListResponse{Users: make([]string, len(users))}
+	for i := range users {
+		resp.Users[i] = string(users[i].Name)
 	}
-
-	return &resp, nil
+	return resp, nil
 }
 
 func (as *authStore) UserRevokeRole(r *pb.AuthUserRevokeRoleRequest) (*pb.AuthUserRevokeRoleResponse, error) {
@@ -546,17 +559,14 @@ func (as *authStore) RoleGet(r *pb.AuthRoleGetRequest) (*pb.AuthRoleGetResponse,
 func (as *authStore) RoleList(r *pb.AuthRoleListRequest) (*pb.AuthRoleListResponse, error) {
 	tx := as.be.BatchTx()
 	tx.Lock()
-	defer tx.Unlock()
-
-	var resp pb.AuthRoleListResponse
-
 	roles := getAllRoles(tx)
+	tx.Unlock()
 
-	for _, r := range roles {
-		resp.Roles = append(resp.Roles, string(r.Name))
+	resp := &pb.AuthRoleListResponse{Roles: make([]string, len(roles))}
+	for i := range roles {
+		resp.Roles[i] = string(roles[i].Name)
 	}
-
-	return &resp, nil
+	return resp, nil
 }
 
 func (as *authStore) RoleRevokePermission(r *pb.AuthRoleRevokePermissionRequest) (*pb.AuthRoleRevokePermissionResponse, error) {
@@ -782,9 +792,9 @@ func (as *authStore) IsAdminPermitted(authInfo *AuthInfo) error {
 
 	tx := as.be.BatchTx()
 	tx.Lock()
-	defer tx.Unlock()
-
 	u := getUser(tx, authInfo.Username)
+	tx.Unlock()
+
 	if u == nil {
 		return ErrUserNotFound
 	}
@@ -816,18 +826,15 @@ func getAllUsers(tx backend.BatchTx) []*authpb.User {
 		return nil
 	}
 
-	var users []*authpb.User
-
-	for _, v := range vs {
+	users := make([]*authpb.User, len(vs))
+	for i := range vs {
 		user := &authpb.User{}
-		err := user.Unmarshal(v)
+		err := user.Unmarshal(vs[i])
 		if err != nil {
 			plog.Panicf("failed to unmarshal user struct: %s", err)
 		}
-
-		users = append(users, user)
+		users[i] = user
 	}
-
 	return users
 }
 
@@ -863,18 +870,15 @@ func getAllRoles(tx backend.BatchTx) []*authpb.Role {
 		return nil
 	}
 
-	var roles []*authpb.Role
-
-	for _, v := range vs {
+	roles := make([]*authpb.Role, len(vs))
+	for i := range vs {
 		role := &authpb.Role{}
-		err := role.Unmarshal(v)
+		err := role.Unmarshal(vs[i])
 		if err != nil {
 			plog.Panicf("failed to unmarshal role struct: %s", err)
 		}
-
-		roles = append(roles, role)
+		roles[i] = role
 	}
-
 	return roles
 }
 
@@ -936,12 +940,9 @@ func NewAuthStore(be backend.Backend, tp TokenProvider) *authStore {
 }
 
 func hasRootRole(u *authpb.User) bool {
-	for _, r := range u.Roles {
-		if r == rootRole {
-			return true
-		}
-	}
-	return false
+	// u.Roles is sorted in UserGrantRole(), so we can use binary search.
+	idx := sort.SearchStrings(u.Roles, rootRole)
+	return idx != len(u.Roles) && u.Roles[idx] == rootRole
 }
 
 func (as *authStore) commitRevision(tx backend.BatchTx) {
@@ -997,8 +998,12 @@ func (as *authStore) AuthInfoFromCtx(ctx context.Context) (*AuthInfo, error) {
 		return nil, nil
 	}
 
-	ts, tok := md["token"]
-	if !tok {
+	//TODO(mitake|hexfusion) review unifying key names
+	ts, ok := md["token"]
+	if !ok {
+		ts, ok = md["authorization"]
+	}
+	if !ok {
 		return nil, nil
 	}
 
@@ -1008,6 +1013,7 @@ func (as *authStore) AuthInfoFromCtx(ctx context.Context) (*AuthInfo, error) {
 		plog.Warningf("invalid auth token: %s", token)
 		return nil, ErrInvalidAuthToken
 	}
+
 	return authInfo, nil
 }
 
@@ -1047,13 +1053,71 @@ func NewTokenProvider(tokenOpts string, indexWaiter func(uint64) <-chan struct{}
 	}
 
 	switch tokenType {
-	case "simple":
+	case tokenTypeSimple:
 		plog.Warningf("simple token is not cryptographically signed")
 		return newTokenProviderSimple(indexWaiter), nil
-	case "jwt":
+
+	case tokenTypeJWT:
 		return newTokenProviderJWT(typeSpecificOpts)
+
+	case "":
+		return newTokenProviderNop()
 	default:
 		plog.Errorf("unknown token type: %s", tokenType)
 		return nil, ErrInvalidAuthOpts
 	}
 }
+
+func (as *authStore) WithRoot(ctx context.Context) context.Context {
+	if !as.isAuthEnabled() {
+		return ctx
+	}
+
+	var ctxForAssign context.Context
+	if ts, ok := as.tokenProvider.(*tokenSimple); ok && ts != nil {
+		ctx1 := context.WithValue(ctx, AuthenticateParamIndex{}, uint64(0))
+		prefix, err := ts.genTokenPrefix()
+		if err != nil {
+			plog.Errorf("failed to generate prefix of internally used token")
+			return ctx
+		}
+		ctxForAssign = context.WithValue(ctx1, AuthenticateParamSimpleTokenPrefix{}, prefix)
+	} else {
+		ctxForAssign = ctx
+	}
+
+	token, err := as.tokenProvider.assign(ctxForAssign, "root", as.Revision())
+	if err != nil {
+		// this must not happen
+		plog.Errorf("failed to assign token for lease revoking: %s", err)
+		return ctx
+	}
+
+	mdMap := map[string]string{
+		"token": token,
+	}
+	tokenMD := metadata.New(mdMap)
+
+	// use "mdIncomingKey{}" since it's called from local etcdserver
+	return metadata.NewIncomingContext(ctx, tokenMD)
+}
+
+func (as *authStore) HasRole(user, role string) bool {
+	tx := as.be.BatchTx()
+	tx.Lock()
+	u := getUser(tx, user)
+	tx.Unlock()
+
+	if u == nil {
+		plog.Warningf("tried to check user %s has role %s, but user %s doesn't exist", user, role, user)
+		return false
+	}
+
+	for _, r := range u.Roles {
+		if role == r {
+			return true
+		}
+	}
+
+	return false
+}
diff --git a/vendor/github.com/coreos/etcd/client/BUILD b/vendor/github.com/coreos/etcd/client/BUILD
index 7dc992647cd..9178134d60e 100644
--- a/vendor/github.com/coreos/etcd/client/BUILD
+++ b/vendor/github.com/coreos/etcd/client/BUILD
@@ -25,7 +25,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/pkg/types:go_default_library",
         "//vendor/github.com/coreos/etcd/version:go_default_library",
         "//vendor/github.com/ugorji/go/codec:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/client/README.md b/vendor/github.com/coreos/etcd/client/README.md
index c0ec8190163..2be731ede0b 100644
--- a/vendor/github.com/coreos/etcd/client/README.md
+++ b/vendor/github.com/coreos/etcd/client/README.md
@@ -25,8 +25,8 @@ package main
 import (
 	"log"
 	"time"
+	"context"
 
-	"golang.org/x/net/context"
 	"github.com/coreos/etcd/client"
 )
 
diff --git a/vendor/github.com/coreos/etcd/client/auth_role.go b/vendor/github.com/coreos/etcd/client/auth_role.go
index d15e00dd716..b6ba7e150dc 100644
--- a/vendor/github.com/coreos/etcd/client/auth_role.go
+++ b/vendor/github.com/coreos/etcd/client/auth_role.go
@@ -16,11 +16,10 @@ package client
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"net/http"
 	"net/url"
-
-	"golang.org/x/net/context"
 )
 
 type Role struct {
diff --git a/vendor/github.com/coreos/etcd/client/auth_user.go b/vendor/github.com/coreos/etcd/client/auth_user.go
index 97c3f31813b..8e7e2efe833 100644
--- a/vendor/github.com/coreos/etcd/client/auth_user.go
+++ b/vendor/github.com/coreos/etcd/client/auth_user.go
@@ -16,12 +16,11 @@ package client
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"net/http"
 	"net/url"
 	"path"
-
-	"golang.org/x/net/context"
 )
 
 var (
diff --git a/vendor/github.com/coreos/etcd/client/client.go b/vendor/github.com/coreos/etcd/client/client.go
index 19ce2ec01da..e6874505666 100644
--- a/vendor/github.com/coreos/etcd/client/client.go
+++ b/vendor/github.com/coreos/etcd/client/client.go
@@ -15,6 +15,7 @@
 package client
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -29,8 +30,6 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/version"
-
-	"golang.org/x/net/context"
 )
 
 var (
@@ -671,8 +670,15 @@ func (r *redirectedHTTPAction) HTTPRequest(ep url.URL) *http.Request {
 }
 
 func shuffleEndpoints(r *rand.Rand, eps []url.URL) []url.URL {
-	p := r.Perm(len(eps))
-	neps := make([]url.URL, len(eps))
+	// copied from Go 1.9<= rand.Rand.Perm
+	n := len(eps)
+	p := make([]int, n)
+	for i := 0; i < n; i++ {
+		j := r.Intn(i + 1)
+		p[i] = p[j]
+		p[j] = i
+	}
+	neps := make([]url.URL, n)
 	for i, k := range p {
 		neps[i] = eps[k]
 	}
diff --git a/vendor/github.com/coreos/etcd/client/doc.go b/vendor/github.com/coreos/etcd/client/doc.go
index 32fdfb52c67..ad4eca4e163 100644
--- a/vendor/github.com/coreos/etcd/client/doc.go
+++ b/vendor/github.com/coreos/etcd/client/doc.go
@@ -19,9 +19,9 @@ Create a Config and exchange it for a Client:
 
 	import (
 		"net/http"
+		"context"
 
 		"github.com/coreos/etcd/client"
-		"golang.org/x/net/context"
 	)
 
 	cfg := client.Config{
@@ -59,7 +59,7 @@ Use a custom context to set timeouts on your operations:
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 
-	// set a new key, ignoring it's previous state
+	// set a new key, ignoring its previous state
 	_, err := kAPI.Set(ctx, "/ping", "pong", nil)
 	if err != nil {
 		if err == context.DeadlineExceeded {
diff --git a/vendor/github.com/coreos/etcd/client/keys.generated.go b/vendor/github.com/coreos/etcd/client/keys.generated.go
index 216139c9cc7..237fdbe8ffd 100644
--- a/vendor/github.com/coreos/etcd/client/keys.generated.go
+++ b/vendor/github.com/coreos/etcd/client/keys.generated.go
@@ -8,49 +8,50 @@ package client
 import (
 	"errors"
 	"fmt"
-	codec1978 "github.com/ugorji/go/codec"
 	"reflect"
 	"runtime"
 	time "time"
+
+	codec1978 "github.com/ugorji/go/codec"
 )
 
 const (
 	// ----- content types ----
-	codecSelferC_UTF81819 = 1
-	codecSelferC_RAW1819  = 0
+	codecSelferC_UTF87612 = 1
+	codecSelferC_RAW7612  = 0
 	// ----- value types used ----
-	codecSelferValueTypeArray1819 = 10
-	codecSelferValueTypeMap1819   = 9
+	codecSelferValueTypeArray7612 = 10
+	codecSelferValueTypeMap7612   = 9
 	// ----- containerStateValues ----
-	codecSelfer_containerMapKey1819    = 2
-	codecSelfer_containerMapValue1819  = 3
-	codecSelfer_containerMapEnd1819    = 4
-	codecSelfer_containerArrayElem1819 = 6
-	codecSelfer_containerArrayEnd1819  = 7
+	codecSelfer_containerMapKey7612    = 2
+	codecSelfer_containerMapValue7612  = 3
+	codecSelfer_containerMapEnd7612    = 4
+	codecSelfer_containerArrayElem7612 = 6
+	codecSelfer_containerArrayEnd7612  = 7
 )
 
 var (
-	codecSelferBitsize1819                         = uint8(reflect.TypeOf(uint(0)).Bits())
-	codecSelferOnlyMapOrArrayEncodeToStructErr1819 = errors.New(`only encoded map or array can be decoded into a struct`)
+	codecSelferBitsize7612                         = uint8(reflect.TypeOf(uint(0)).Bits())
+	codecSelferOnlyMapOrArrayEncodeToStructErr7612 = errors.New(`only encoded map or array can be decoded into a struct`)
 )
 
-type codecSelfer1819 struct{}
+type codecSelfer7612 struct{}
 
 func init() {
-	if codec1978.GenVersion != 5 {
+	if codec1978.GenVersion != 8 {
 		_, file, _, _ := runtime.Caller(0)
 		err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
-			5, codec1978.GenVersion, file)
+			8, codec1978.GenVersion, file)
 		panic(err)
 	}
 	if false { // reference the types, but skip this branch at build/run time
-		var v0 time.Time
+		var v0 time.Duration
 		_ = v0
 	}
 }
 
-func (x *Response) CodecEncodeSelf(e *codec1978.Encoder) {
-	var h codecSelfer1819
+func (x *Error) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperEncoder(e)
 	_, _, _ = h, z, r
 	if x == nil {
@@ -63,86 +64,100 @@ func (x *Response) CodecEncodeSelf(e *codec1978.Encoder) {
 		} else {
 			yysep2 := !z.EncBinary()
 			yy2arr2 := z.EncBasicHandle().StructToArray
-			var yyq2 [3]bool
-			_, _, _ = yysep2, yyq2, yy2arr2
+			_, _ = yysep2, yy2arr2
 			const yyr2 bool = false
-			var yynn2 int
 			if yyr2 || yy2arr2 {
-				r.EncodeArrayStart(3)
+				r.WriteArrayStart(4)
 			} else {
-				yynn2 = 3
-				for _, b := range yyq2 {
-					if b {
-						yynn2++
-					}
-				}
-				r.EncodeMapStart(yynn2)
-				yynn2 = 0
+				r.WriteMapStart(4)
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
+				r.WriteArrayElem()
 				yym4 := z.EncBinary()
 				_ = yym4
 				if false {
 				} else {
-					r.EncodeString(codecSelferC_UTF81819, string(x.Action))
+					r.EncodeInt(int64(x.Code))
 				}
 			} else {
-				z.EncSendContainerState(codecSelfer_containerMapKey1819)
-				r.EncodeString(codecSelferC_UTF81819, string("action"))
-				z.EncSendContainerState(codecSelfer_containerMapValue1819)
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("errorCode"))
+				r.WriteMapElemValue()
 				yym5 := z.EncBinary()
 				_ = yym5
 				if false {
 				} else {
-					r.EncodeString(codecSelferC_UTF81819, string(x.Action))
+					r.EncodeInt(int64(x.Code))
 				}
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
-				if x.Node == nil {
-					r.EncodeNil()
+				r.WriteArrayElem()
+				yym7 := z.EncBinary()
+				_ = yym7
+				if false {
 				} else {
-					x.Node.CodecEncodeSelf(e)
+					r.EncodeString(codecSelferC_UTF87612, string(x.Message))
 				}
 			} else {
-				z.EncSendContainerState(codecSelfer_containerMapKey1819)
-				r.EncodeString(codecSelferC_UTF81819, string("node"))
-				z.EncSendContainerState(codecSelfer_containerMapValue1819)
-				if x.Node == nil {
-					r.EncodeNil()
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("message"))
+				r.WriteMapElemValue()
+				yym8 := z.EncBinary()
+				_ = yym8
+				if false {
 				} else {
-					x.Node.CodecEncodeSelf(e)
+					r.EncodeString(codecSelferC_UTF87612, string(x.Message))
 				}
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
-				if x.PrevNode == nil {
-					r.EncodeNil()
+				r.WriteArrayElem()
+				yym10 := z.EncBinary()
+				_ = yym10
+				if false {
 				} else {
-					x.PrevNode.CodecEncodeSelf(e)
+					r.EncodeString(codecSelferC_UTF87612, string(x.Cause))
 				}
 			} else {
-				z.EncSendContainerState(codecSelfer_containerMapKey1819)
-				r.EncodeString(codecSelferC_UTF81819, string("prevNode"))
-				z.EncSendContainerState(codecSelfer_containerMapValue1819)
-				if x.PrevNode == nil {
-					r.EncodeNil()
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("cause"))
+				r.WriteMapElemValue()
+				yym11 := z.EncBinary()
+				_ = yym11
+				if false {
 				} else {
-					x.PrevNode.CodecEncodeSelf(e)
+					r.EncodeString(codecSelferC_UTF87612, string(x.Cause))
 				}
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayEnd1819)
+				r.WriteArrayElem()
+				yym13 := z.EncBinary()
+				_ = yym13
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.Index))
+				}
 			} else {
-				z.EncSendContainerState(codecSelfer_containerMapEnd1819)
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("index"))
+				r.WriteMapElemValue()
+				yym14 := z.EncBinary()
+				_ = yym14
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.Index))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
 			}
 		}
 	}
 }
 
-func (x *Response) CodecDecodeSelf(d *codec1978.Decoder) {
-	var h codecSelfer1819
+func (x *Error) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperDecoder(d)
 	_, _, _ = h, z, r
 	yym1 := z.DecBinary()
@@ -151,28 +166,28 @@ func (x *Response) CodecDecodeSelf(d *codec1978.Decoder) {
 	} else if z.HasExtensions() && z.DecExt(x) {
 	} else {
 		yyct2 := r.ContainerType()
-		if yyct2 == codecSelferValueTypeMap1819 {
+		if yyct2 == codecSelferValueTypeMap7612 {
 			yyl2 := r.ReadMapStart()
 			if yyl2 == 0 {
-				z.DecSendContainerState(codecSelfer_containerMapEnd1819)
+				r.ReadMapEnd()
 			} else {
 				x.codecDecodeSelfFromMap(yyl2, d)
 			}
-		} else if yyct2 == codecSelferValueTypeArray1819 {
+		} else if yyct2 == codecSelferValueTypeArray7612 {
 			yyl2 := r.ReadArrayStart()
 			if yyl2 == 0 {
-				z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+				r.ReadArrayEnd()
 			} else {
 				x.codecDecodeSelfFromArray(yyl2, d)
 			}
 		} else {
-			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1819)
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
 		}
 	}
 }
 
-func (x *Response) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
-	var h codecSelfer1819
+func (x *Error) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperDecoder(d)
 	_, _, _ = h, z, r
 	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
@@ -188,10 +203,1816 @@ func (x *Response) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 				break
 			}
 		}
-		z.DecSendContainerState(codecSelfer_containerMapKey1819)
-		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
 		yys3 := string(yys3Slc)
-		z.DecSendContainerState(codecSelfer_containerMapValue1819)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "errorCode":
+			if r.TryDecodeAsNil() {
+				x.Code = 0
+			} else {
+				yyv4 := &x.Code
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else {
+					*((*int)(yyv4)) = int(r.DecodeInt(codecSelferBitsize7612))
+				}
+			}
+		case "message":
+			if r.TryDecodeAsNil() {
+				x.Message = ""
+			} else {
+				yyv6 := &x.Message
+				yym7 := z.DecBinary()
+				_ = yym7
+				if false {
+				} else {
+					*((*string)(yyv6)) = r.DecodeString()
+				}
+			}
+		case "cause":
+			if r.TryDecodeAsNil() {
+				x.Cause = ""
+			} else {
+				yyv8 := &x.Cause
+				yym9 := z.DecBinary()
+				_ = yym9
+				if false {
+				} else {
+					*((*string)(yyv8)) = r.DecodeString()
+				}
+			}
+		case "index":
+			if r.TryDecodeAsNil() {
+				x.Index = 0
+			} else {
+				yyv10 := &x.Index
+				yym11 := z.DecBinary()
+				_ = yym11
+				if false {
+				} else {
+					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *Error) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj12 int
+	var yyb12 bool
+	var yyhl12 bool = l >= 0
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Code = 0
+	} else {
+		yyv13 := &x.Code
+		yym14 := z.DecBinary()
+		_ = yym14
+		if false {
+		} else {
+			*((*int)(yyv13)) = int(r.DecodeInt(codecSelferBitsize7612))
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Message = ""
+	} else {
+		yyv15 := &x.Message
+		yym16 := z.DecBinary()
+		_ = yym16
+		if false {
+		} else {
+			*((*string)(yyv15)) = r.DecodeString()
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Cause = ""
+	} else {
+		yyv17 := &x.Cause
+		yym18 := z.DecBinary()
+		_ = yym18
+		if false {
+		} else {
+			*((*string)(yyv17)) = r.DecodeString()
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Index = 0
+	} else {
+		yyv19 := &x.Index
+		yym20 := z.DecBinary()
+		_ = yym20
+		if false {
+		} else {
+			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
+		}
+	}
+	for {
+		yyj12++
+		if yyhl12 {
+			yyb12 = yyj12 > l
+		} else {
+			yyb12 = r.CheckBreak()
+		}
+		if yyb12 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj12-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x PrevExistType) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	yym1 := z.EncBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.EncExt(x) {
+	} else {
+		r.EncodeString(codecSelferC_UTF87612, string(x))
+	}
+}
+
+func (x *PrevExistType) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		*((*string)(x)) = r.DecodeString()
+	}
+}
+
+func (x *WatcherOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(2)
+			} else {
+				r.WriteMapStart(2)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.AfterIndex))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("AfterIndex"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.AfterIndex))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym7 := z.EncBinary()
+				_ = yym7
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Recursive"))
+				r.WriteMapElemValue()
+				yym8 := z.EncBinary()
+				_ = yym8
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *WatcherOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *WatcherOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "AfterIndex":
+			if r.TryDecodeAsNil() {
+				x.AfterIndex = 0
+			} else {
+				yyv4 := &x.AfterIndex
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else {
+					*((*uint64)(yyv4)) = uint64(r.DecodeUint(64))
+				}
+			}
+		case "Recursive":
+			if r.TryDecodeAsNil() {
+				x.Recursive = false
+			} else {
+				yyv6 := &x.Recursive
+				yym7 := z.DecBinary()
+				_ = yym7
+				if false {
+				} else {
+					*((*bool)(yyv6)) = r.DecodeBool()
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *WatcherOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj8 int
+	var yyb8 bool
+	var yyhl8 bool = l >= 0
+	yyj8++
+	if yyhl8 {
+		yyb8 = yyj8 > l
+	} else {
+		yyb8 = r.CheckBreak()
+	}
+	if yyb8 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.AfterIndex = 0
+	} else {
+		yyv9 := &x.AfterIndex
+		yym10 := z.DecBinary()
+		_ = yym10
+		if false {
+		} else {
+			*((*uint64)(yyv9)) = uint64(r.DecodeUint(64))
+		}
+	}
+	yyj8++
+	if yyhl8 {
+		yyb8 = yyj8 > l
+	} else {
+		yyb8 = r.CheckBreak()
+	}
+	if yyb8 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Recursive = false
+	} else {
+		yyv11 := &x.Recursive
+		yym12 := z.DecBinary()
+		_ = yym12
+		if false {
+		} else {
+			*((*bool)(yyv11)) = r.DecodeBool()
+		}
+	}
+	for {
+		yyj8++
+		if yyhl8 {
+			yyb8 = yyj8 > l
+		} else {
+			yyb8 = r.CheckBreak()
+		}
+		if yyb8 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj8-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *CreateInOrderOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(1)
+			} else {
+				r.WriteMapStart(1)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else if z.HasExtensions() && z.EncExt(x.TTL) {
+				} else {
+					r.EncodeInt(int64(x.TTL))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("TTL"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else if z.HasExtensions() && z.EncExt(x.TTL) {
+				} else {
+					r.EncodeInt(int64(x.TTL))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *CreateInOrderOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *CreateInOrderOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "TTL":
+			if r.TryDecodeAsNil() {
+				x.TTL = 0
+			} else {
+				yyv4 := &x.TTL
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else if z.HasExtensions() && z.DecExt(yyv4) {
+				} else {
+					*((*int64)(yyv4)) = int64(r.DecodeInt(64))
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *CreateInOrderOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj6 int
+	var yyb6 bool
+	var yyhl6 bool = l >= 0
+	yyj6++
+	if yyhl6 {
+		yyb6 = yyj6 > l
+	} else {
+		yyb6 = r.CheckBreak()
+	}
+	if yyb6 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.TTL = 0
+	} else {
+		yyv7 := &x.TTL
+		yym8 := z.DecBinary()
+		_ = yym8
+		if false {
+		} else if z.HasExtensions() && z.DecExt(yyv7) {
+		} else {
+			*((*int64)(yyv7)) = int64(r.DecodeInt(64))
+		}
+	}
+	for {
+		yyj6++
+		if yyhl6 {
+			yyb6 = yyj6 > l
+		} else {
+			yyb6 = r.CheckBreak()
+		}
+		if yyb6 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj6-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *SetOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(7)
+			} else {
+				r.WriteMapStart(7)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.PrevValue))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("PrevValue"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.PrevValue))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym7 := z.EncBinary()
+				_ = yym7
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.PrevIndex))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("PrevIndex"))
+				r.WriteMapElemValue()
+				yym8 := z.EncBinary()
+				_ = yym8
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.PrevIndex))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				x.PrevExist.CodecEncodeSelf(e)
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("PrevExist"))
+				r.WriteMapElemValue()
+				x.PrevExist.CodecEncodeSelf(e)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym13 := z.EncBinary()
+				_ = yym13
+				if false {
+				} else if z.HasExtensions() && z.EncExt(x.TTL) {
+				} else {
+					r.EncodeInt(int64(x.TTL))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("TTL"))
+				r.WriteMapElemValue()
+				yym14 := z.EncBinary()
+				_ = yym14
+				if false {
+				} else if z.HasExtensions() && z.EncExt(x.TTL) {
+				} else {
+					r.EncodeInt(int64(x.TTL))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym16 := z.EncBinary()
+				_ = yym16
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Refresh))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Refresh"))
+				r.WriteMapElemValue()
+				yym17 := z.EncBinary()
+				_ = yym17
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Refresh))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym19 := z.EncBinary()
+				_ = yym19
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Dir))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Dir"))
+				r.WriteMapElemValue()
+				yym20 := z.EncBinary()
+				_ = yym20
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Dir))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym22 := z.EncBinary()
+				_ = yym22
+				if false {
+				} else {
+					r.EncodeBool(bool(x.NoValueOnSuccess))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("NoValueOnSuccess"))
+				r.WriteMapElemValue()
+				yym23 := z.EncBinary()
+				_ = yym23
+				if false {
+				} else {
+					r.EncodeBool(bool(x.NoValueOnSuccess))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *SetOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *SetOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "PrevValue":
+			if r.TryDecodeAsNil() {
+				x.PrevValue = ""
+			} else {
+				yyv4 := &x.PrevValue
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else {
+					*((*string)(yyv4)) = r.DecodeString()
+				}
+			}
+		case "PrevIndex":
+			if r.TryDecodeAsNil() {
+				x.PrevIndex = 0
+			} else {
+				yyv6 := &x.PrevIndex
+				yym7 := z.DecBinary()
+				_ = yym7
+				if false {
+				} else {
+					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
+				}
+			}
+		case "PrevExist":
+			if r.TryDecodeAsNil() {
+				x.PrevExist = ""
+			} else {
+				yyv8 := &x.PrevExist
+				yyv8.CodecDecodeSelf(d)
+			}
+		case "TTL":
+			if r.TryDecodeAsNil() {
+				x.TTL = 0
+			} else {
+				yyv9 := &x.TTL
+				yym10 := z.DecBinary()
+				_ = yym10
+				if false {
+				} else if z.HasExtensions() && z.DecExt(yyv9) {
+				} else {
+					*((*int64)(yyv9)) = int64(r.DecodeInt(64))
+				}
+			}
+		case "Refresh":
+			if r.TryDecodeAsNil() {
+				x.Refresh = false
+			} else {
+				yyv11 := &x.Refresh
+				yym12 := z.DecBinary()
+				_ = yym12
+				if false {
+				} else {
+					*((*bool)(yyv11)) = r.DecodeBool()
+				}
+			}
+		case "Dir":
+			if r.TryDecodeAsNil() {
+				x.Dir = false
+			} else {
+				yyv13 := &x.Dir
+				yym14 := z.DecBinary()
+				_ = yym14
+				if false {
+				} else {
+					*((*bool)(yyv13)) = r.DecodeBool()
+				}
+			}
+		case "NoValueOnSuccess":
+			if r.TryDecodeAsNil() {
+				x.NoValueOnSuccess = false
+			} else {
+				yyv15 := &x.NoValueOnSuccess
+				yym16 := z.DecBinary()
+				_ = yym16
+				if false {
+				} else {
+					*((*bool)(yyv15)) = r.DecodeBool()
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *SetOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj17 int
+	var yyb17 bool
+	var yyhl17 bool = l >= 0
+	yyj17++
+	if yyhl17 {
+		yyb17 = yyj17 > l
+	} else {
+		yyb17 = r.CheckBreak()
+	}
+	if yyb17 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.PrevValue = ""
+	} else {
+		yyv18 := &x.PrevValue
+		yym19 := z.DecBinary()
+		_ = yym19
+		if false {
+		} else {
+			*((*string)(yyv18)) = r.DecodeString()
+		}
+	}
+	yyj17++
+	if yyhl17 {
+		yyb17 = yyj17 > l
+	} else {
+		yyb17 = r.CheckBreak()
+	}
+	if yyb17 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.PrevIndex = 0
+	} else {
+		yyv20 := &x.PrevIndex
+		yym21 := z.DecBinary()
+		_ = yym21
+		if false {
+		} else {
+			*((*uint64)(yyv20)) = uint64(r.DecodeUint(64))
+		}
+	}
+	yyj17++
+	if yyhl17 {
+		yyb17 = yyj17 > l
+	} else {
+		yyb17 = r.CheckBreak()
+	}
+	if yyb17 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.PrevExist = ""
+	} else {
+		yyv22 := &x.PrevExist
+		yyv22.CodecDecodeSelf(d)
+	}
+	yyj17++
+	if yyhl17 {
+		yyb17 = yyj17 > l
+	} else {
+		yyb17 = r.CheckBreak()
+	}
+	if yyb17 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.TTL = 0
+	} else {
+		yyv23 := &x.TTL
+		yym24 := z.DecBinary()
+		_ = yym24
+		if false {
+		} else if z.HasExtensions() && z.DecExt(yyv23) {
+		} else {
+			*((*int64)(yyv23)) = int64(r.DecodeInt(64))
+		}
+	}
+	yyj17++
+	if yyhl17 {
+		yyb17 = yyj17 > l
+	} else {
+		yyb17 = r.CheckBreak()
+	}
+	if yyb17 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Refresh = false
+	} else {
+		yyv25 := &x.Refresh
+		yym26 := z.DecBinary()
+		_ = yym26
+		if false {
+		} else {
+			*((*bool)(yyv25)) = r.DecodeBool()
+		}
+	}
+	yyj17++
+	if yyhl17 {
+		yyb17 = yyj17 > l
+	} else {
+		yyb17 = r.CheckBreak()
+	}
+	if yyb17 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Dir = false
+	} else {
+		yyv27 := &x.Dir
+		yym28 := z.DecBinary()
+		_ = yym28
+		if false {
+		} else {
+			*((*bool)(yyv27)) = r.DecodeBool()
+		}
+	}
+	yyj17++
+	if yyhl17 {
+		yyb17 = yyj17 > l
+	} else {
+		yyb17 = r.CheckBreak()
+	}
+	if yyb17 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.NoValueOnSuccess = false
+	} else {
+		yyv29 := &x.NoValueOnSuccess
+		yym30 := z.DecBinary()
+		_ = yym30
+		if false {
+		} else {
+			*((*bool)(yyv29)) = r.DecodeBool()
+		}
+	}
+	for {
+		yyj17++
+		if yyhl17 {
+			yyb17 = yyj17 > l
+		} else {
+			yyb17 = r.CheckBreak()
+		}
+		if yyb17 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj17-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *GetOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(3)
+			} else {
+				r.WriteMapStart(3)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Recursive"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym7 := z.EncBinary()
+				_ = yym7
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Sort))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Sort"))
+				r.WriteMapElemValue()
+				yym8 := z.EncBinary()
+				_ = yym8
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Sort))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym10 := z.EncBinary()
+				_ = yym10
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Quorum))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Quorum"))
+				r.WriteMapElemValue()
+				yym11 := z.EncBinary()
+				_ = yym11
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Quorum))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *GetOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *GetOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "Recursive":
+			if r.TryDecodeAsNil() {
+				x.Recursive = false
+			} else {
+				yyv4 := &x.Recursive
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else {
+					*((*bool)(yyv4)) = r.DecodeBool()
+				}
+			}
+		case "Sort":
+			if r.TryDecodeAsNil() {
+				x.Sort = false
+			} else {
+				yyv6 := &x.Sort
+				yym7 := z.DecBinary()
+				_ = yym7
+				if false {
+				} else {
+					*((*bool)(yyv6)) = r.DecodeBool()
+				}
+			}
+		case "Quorum":
+			if r.TryDecodeAsNil() {
+				x.Quorum = false
+			} else {
+				yyv8 := &x.Quorum
+				yym9 := z.DecBinary()
+				_ = yym9
+				if false {
+				} else {
+					*((*bool)(yyv8)) = r.DecodeBool()
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *GetOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj10 int
+	var yyb10 bool
+	var yyhl10 bool = l >= 0
+	yyj10++
+	if yyhl10 {
+		yyb10 = yyj10 > l
+	} else {
+		yyb10 = r.CheckBreak()
+	}
+	if yyb10 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Recursive = false
+	} else {
+		yyv11 := &x.Recursive
+		yym12 := z.DecBinary()
+		_ = yym12
+		if false {
+		} else {
+			*((*bool)(yyv11)) = r.DecodeBool()
+		}
+	}
+	yyj10++
+	if yyhl10 {
+		yyb10 = yyj10 > l
+	} else {
+		yyb10 = r.CheckBreak()
+	}
+	if yyb10 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Sort = false
+	} else {
+		yyv13 := &x.Sort
+		yym14 := z.DecBinary()
+		_ = yym14
+		if false {
+		} else {
+			*((*bool)(yyv13)) = r.DecodeBool()
+		}
+	}
+	yyj10++
+	if yyhl10 {
+		yyb10 = yyj10 > l
+	} else {
+		yyb10 = r.CheckBreak()
+	}
+	if yyb10 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Quorum = false
+	} else {
+		yyv15 := &x.Quorum
+		yym16 := z.DecBinary()
+		_ = yym16
+		if false {
+		} else {
+			*((*bool)(yyv15)) = r.DecodeBool()
+		}
+	}
+	for {
+		yyj10++
+		if yyhl10 {
+			yyb10 = yyj10 > l
+		} else {
+			yyb10 = r.CheckBreak()
+		}
+		if yyb10 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj10-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(4)
+			} else {
+				r.WriteMapStart(4)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.PrevValue))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("PrevValue"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.PrevValue))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym7 := z.EncBinary()
+				_ = yym7
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.PrevIndex))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("PrevIndex"))
+				r.WriteMapElemValue()
+				yym8 := z.EncBinary()
+				_ = yym8
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.PrevIndex))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym10 := z.EncBinary()
+				_ = yym10
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Recursive"))
+				r.WriteMapElemValue()
+				yym11 := z.EncBinary()
+				_ = yym11
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym13 := z.EncBinary()
+				_ = yym13
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Dir))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Dir"))
+				r.WriteMapElemValue()
+				yym14 := z.EncBinary()
+				_ = yym14
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Dir))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *DeleteOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "PrevValue":
+			if r.TryDecodeAsNil() {
+				x.PrevValue = ""
+			} else {
+				yyv4 := &x.PrevValue
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else {
+					*((*string)(yyv4)) = r.DecodeString()
+				}
+			}
+		case "PrevIndex":
+			if r.TryDecodeAsNil() {
+				x.PrevIndex = 0
+			} else {
+				yyv6 := &x.PrevIndex
+				yym7 := z.DecBinary()
+				_ = yym7
+				if false {
+				} else {
+					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
+				}
+			}
+		case "Recursive":
+			if r.TryDecodeAsNil() {
+				x.Recursive = false
+			} else {
+				yyv8 := &x.Recursive
+				yym9 := z.DecBinary()
+				_ = yym9
+				if false {
+				} else {
+					*((*bool)(yyv8)) = r.DecodeBool()
+				}
+			}
+		case "Dir":
+			if r.TryDecodeAsNil() {
+				x.Dir = false
+			} else {
+				yyv10 := &x.Dir
+				yym11 := z.DecBinary()
+				_ = yym11
+				if false {
+				} else {
+					*((*bool)(yyv10)) = r.DecodeBool()
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj12 int
+	var yyb12 bool
+	var yyhl12 bool = l >= 0
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.PrevValue = ""
+	} else {
+		yyv13 := &x.PrevValue
+		yym14 := z.DecBinary()
+		_ = yym14
+		if false {
+		} else {
+			*((*string)(yyv13)) = r.DecodeString()
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.PrevIndex = 0
+	} else {
+		yyv15 := &x.PrevIndex
+		yym16 := z.DecBinary()
+		_ = yym16
+		if false {
+		} else {
+			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Recursive = false
+	} else {
+		yyv17 := &x.Recursive
+		yym18 := z.DecBinary()
+		_ = yym18
+		if false {
+		} else {
+			*((*bool)(yyv17)) = r.DecodeBool()
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Dir = false
+	} else {
+		yyv19 := &x.Dir
+		yym20 := z.DecBinary()
+		_ = yym20
+		if false {
+		} else {
+			*((*bool)(yyv19)) = r.DecodeBool()
+		}
+	}
+	for {
+		yyj12++
+		if yyhl12 {
+			yyb12 = yyj12 > l
+		} else {
+			yyb12 = r.CheckBreak()
+		}
+		if yyb12 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj12-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *Response) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(3)
+			} else {
+				r.WriteMapStart(3)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Action))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("action"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Action))
+				}
+			}
+			var yyn6 bool
+			if x.Node == nil {
+				yyn6 = true
+				goto LABEL6
+			}
+		LABEL6:
+			if yyr2 || yy2arr2 {
+				if yyn6 {
+					r.WriteArrayElem()
+					r.EncodeNil()
+				} else {
+					r.WriteArrayElem()
+					if x.Node == nil {
+						r.EncodeNil()
+					} else {
+						x.Node.CodecEncodeSelf(e)
+					}
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("node"))
+				r.WriteMapElemValue()
+				if yyn6 {
+					r.EncodeNil()
+				} else {
+					if x.Node == nil {
+						r.EncodeNil()
+					} else {
+						x.Node.CodecEncodeSelf(e)
+					}
+				}
+			}
+			var yyn9 bool
+			if x.PrevNode == nil {
+				yyn9 = true
+				goto LABEL9
+			}
+		LABEL9:
+			if yyr2 || yy2arr2 {
+				if yyn9 {
+					r.WriteArrayElem()
+					r.EncodeNil()
+				} else {
+					r.WriteArrayElem()
+					if x.PrevNode == nil {
+						r.EncodeNil()
+					} else {
+						x.PrevNode.CodecEncodeSelf(e)
+					}
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("prevNode"))
+				r.WriteMapElemValue()
+				if yyn9 {
+					r.EncodeNil()
+				} else {
+					if x.PrevNode == nil {
+						r.EncodeNil()
+					} else {
+						x.PrevNode.CodecEncodeSelf(e)
+					}
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *Response) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *Response) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
 		switch yys3 {
 		case "action":
 			if r.TryDecodeAsNil() {
@@ -206,6 +2027,9 @@ func (x *Response) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 				}
 			}
 		case "node":
+			if x.Node == nil {
+				x.Node = new(Node)
+			}
 			if r.TryDecodeAsNil() {
 				if x.Node != nil {
 					x.Node = nil
@@ -217,6 +2041,9 @@ func (x *Response) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 				x.Node.CodecDecodeSelf(d)
 			}
 		case "prevNode":
+			if x.PrevNode == nil {
+				x.PrevNode = new(Node)
+			}
 			if r.TryDecodeAsNil() {
 				if x.PrevNode != nil {
 					x.PrevNode = nil
@@ -231,11 +2058,11 @@ func (x *Response) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 			z.DecStructFieldNotFound(-1, yys3)
 		} // end switch yys3
 	} // end for yyj3
-	z.DecSendContainerState(codecSelfer_containerMapEnd1819)
+	r.ReadMapEnd()
 }
 
 func (x *Response) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
-	var h codecSelfer1819
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperDecoder(d)
 	_, _, _ = h, z, r
 	var yyj8 int
@@ -248,10 +2075,10 @@ func (x *Response) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb8 = r.CheckBreak()
 	}
 	if yyb8 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		x.Action = ""
 	} else {
@@ -263,6 +2090,9 @@ func (x *Response) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 			*((*string)(yyv9)) = r.DecodeString()
 		}
 	}
+	if x.Node == nil {
+		x.Node = new(Node)
+	}
 	yyj8++
 	if yyhl8 {
 		yyb8 = yyj8 > l
@@ -270,10 +2100,10 @@ func (x *Response) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb8 = r.CheckBreak()
 	}
 	if yyb8 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		if x.Node != nil {
 			x.Node = nil
@@ -284,6 +2114,9 @@ func (x *Response) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		}
 		x.Node.CodecDecodeSelf(d)
 	}
+	if x.PrevNode == nil {
+		x.PrevNode = new(Node)
+	}
 	yyj8++
 	if yyhl8 {
 		yyb8 = yyj8 > l
@@ -291,10 +2124,10 @@ func (x *Response) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb8 = r.CheckBreak()
 	}
 	if yyb8 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		if x.PrevNode != nil {
 			x.PrevNode = nil
@@ -315,14 +2148,14 @@ func (x *Response) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		if yyb8 {
 			break
 		}
-		z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+		r.ReadArrayElem()
 		z.DecStructFieldNotFound(yyj8-1, "")
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+	r.ReadArrayEnd()
 }
 
 func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
-	var h codecSelfer1819
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperEncoder(e)
 	_, _, _ = h, z, r
 	if x == nil {
@@ -336,45 +2169,44 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 			yysep2 := !z.EncBinary()
 			yy2arr2 := z.EncBasicHandle().StructToArray
 			var yyq2 [8]bool
-			_, _, _ = yysep2, yyq2, yy2arr2
+			_ = yyq2
+			_, _ = yysep2, yy2arr2
 			const yyr2 bool = false
 			yyq2[1] = x.Dir != false
 			yyq2[6] = x.Expiration != nil
 			yyq2[7] = x.TTL != 0
-			var yynn2 int
 			if yyr2 || yy2arr2 {
-				r.EncodeArrayStart(8)
+				r.WriteArrayStart(8)
 			} else {
-				yynn2 = 5
+				var yynn2 = 5
 				for _, b := range yyq2 {
 					if b {
 						yynn2++
 					}
 				}
-				r.EncodeMapStart(yynn2)
-				yynn2 = 0
+				r.WriteMapStart(yynn2)
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
+				r.WriteArrayElem()
 				yym4 := z.EncBinary()
 				_ = yym4
 				if false {
 				} else {
-					r.EncodeString(codecSelferC_UTF81819, string(x.Key))
+					r.EncodeString(codecSelferC_UTF87612, string(x.Key))
 				}
 			} else {
-				z.EncSendContainerState(codecSelfer_containerMapKey1819)
-				r.EncodeString(codecSelferC_UTF81819, string("key"))
-				z.EncSendContainerState(codecSelfer_containerMapValue1819)
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("key"))
+				r.WriteMapElemValue()
 				yym5 := z.EncBinary()
 				_ = yym5
 				if false {
 				} else {
-					r.EncodeString(codecSelferC_UTF81819, string(x.Key))
+					r.EncodeString(codecSelferC_UTF87612, string(x.Key))
 				}
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
+				r.WriteArrayElem()
 				if yyq2[1] {
 					yym7 := z.EncBinary()
 					_ = yym7
@@ -387,9 +2219,9 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 				}
 			} else {
 				if yyq2[1] {
-					z.EncSendContainerState(codecSelfer_containerMapKey1819)
-					r.EncodeString(codecSelferC_UTF81819, string("dir"))
-					z.EncSendContainerState(codecSelfer_containerMapValue1819)
+					r.WriteMapElemKey()
+					r.EncodeString(codecSelferC_UTF87612, string("dir"))
+					r.WriteMapElemValue()
 					yym8 := z.EncBinary()
 					_ = yym8
 					if false {
@@ -399,35 +2231,35 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 				}
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
+				r.WriteArrayElem()
 				yym10 := z.EncBinary()
 				_ = yym10
 				if false {
 				} else {
-					r.EncodeString(codecSelferC_UTF81819, string(x.Value))
+					r.EncodeString(codecSelferC_UTF87612, string(x.Value))
 				}
 			} else {
-				z.EncSendContainerState(codecSelfer_containerMapKey1819)
-				r.EncodeString(codecSelferC_UTF81819, string("value"))
-				z.EncSendContainerState(codecSelfer_containerMapValue1819)
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("value"))
+				r.WriteMapElemValue()
 				yym11 := z.EncBinary()
 				_ = yym11
 				if false {
 				} else {
-					r.EncodeString(codecSelferC_UTF81819, string(x.Value))
+					r.EncodeString(codecSelferC_UTF87612, string(x.Value))
 				}
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
+				r.WriteArrayElem()
 				if x.Nodes == nil {
 					r.EncodeNil()
 				} else {
 					x.Nodes.CodecEncodeSelf(e)
 				}
 			} else {
-				z.EncSendContainerState(codecSelfer_containerMapKey1819)
-				r.EncodeString(codecSelferC_UTF81819, string("nodes"))
-				z.EncSendContainerState(codecSelfer_containerMapValue1819)
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("nodes"))
+				r.WriteMapElemValue()
 				if x.Nodes == nil {
 					r.EncodeNil()
 				} else {
@@ -435,7 +2267,7 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 				}
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
+				r.WriteArrayElem()
 				yym16 := z.EncBinary()
 				_ = yym16
 				if false {
@@ -443,9 +2275,9 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 					r.EncodeUint(uint64(x.CreatedIndex))
 				}
 			} else {
-				z.EncSendContainerState(codecSelfer_containerMapKey1819)
-				r.EncodeString(codecSelferC_UTF81819, string("createdIndex"))
-				z.EncSendContainerState(codecSelfer_containerMapValue1819)
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("createdIndex"))
+				r.WriteMapElemValue()
 				yym17 := z.EncBinary()
 				_ = yym17
 				if false {
@@ -454,7 +2286,7 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 				}
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
+				r.WriteArrayElem()
 				yym19 := z.EncBinary()
 				_ = yym19
 				if false {
@@ -462,9 +2294,9 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 					r.EncodeUint(uint64(x.ModifiedIndex))
 				}
 			} else {
-				z.EncSendContainerState(codecSelfer_containerMapKey1819)
-				r.EncodeString(codecSelferC_UTF81819, string("modifiedIndex"))
-				z.EncSendContainerState(codecSelfer_containerMapValue1819)
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("modifiedIndex"))
+				r.WriteMapElemValue()
 				yym20 := z.EncBinary()
 				_ = yym20
 				if false {
@@ -472,55 +2304,70 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 					r.EncodeUint(uint64(x.ModifiedIndex))
 				}
 			}
+			var yyn21 bool
+			if x.Expiration == nil {
+				yyn21 = true
+				goto LABEL21
+			}
+		LABEL21:
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
-				if yyq2[6] {
-					if x.Expiration == nil {
-						r.EncodeNil()
-					} else {
-						yym22 := z.EncBinary()
-						_ = yym22
-						if false {
-						} else if yym23 := z.TimeRtidIfBinc(); yym23 != 0 {
-							r.EncodeBuiltin(yym23, x.Expiration)
-						} else if z.HasExtensions() && z.EncExt(x.Expiration) {
-						} else if yym22 {
-							z.EncBinaryMarshal(x.Expiration)
-						} else if !yym22 && z.IsJSONHandle() {
-							z.EncJSONMarshal(x.Expiration)
-						} else {
-							z.EncFallback(x.Expiration)
-						}
-					}
-				} else {
+				if yyn21 {
+					r.WriteArrayElem()
 					r.EncodeNil()
+				} else {
+					r.WriteArrayElem()
+					if yyq2[6] {
+						if x.Expiration == nil {
+							r.EncodeNil()
+						} else {
+							yym22 := z.EncBinary()
+							_ = yym22
+							if false {
+							} else if yym23 := z.TimeRtidIfBinc(); yym23 != 0 {
+								r.EncodeBuiltin(yym23, x.Expiration)
+							} else if z.HasExtensions() && z.EncExt(x.Expiration) {
+							} else if yym22 {
+								z.EncBinaryMarshal(x.Expiration)
+							} else if !yym22 && z.IsJSONHandle() {
+								z.EncJSONMarshal(x.Expiration)
+							} else {
+								z.EncFallback(x.Expiration)
+							}
+						}
+					} else {
+						r.EncodeNil()
+					}
 				}
 			} else {
 				if yyq2[6] {
-					z.EncSendContainerState(codecSelfer_containerMapKey1819)
-					r.EncodeString(codecSelferC_UTF81819, string("expiration"))
-					z.EncSendContainerState(codecSelfer_containerMapValue1819)
-					if x.Expiration == nil {
+					r.WriteMapElemKey()
+					r.EncodeString(codecSelferC_UTF87612, string("expiration"))
+					r.WriteMapElemValue()
+					if yyn21 {
 						r.EncodeNil()
 					} else {
-						yym24 := z.EncBinary()
-						_ = yym24
-						if false {
-						} else if yym25 := z.TimeRtidIfBinc(); yym25 != 0 {
-							r.EncodeBuiltin(yym25, x.Expiration)
-						} else if z.HasExtensions() && z.EncExt(x.Expiration) {
-						} else if yym24 {
-							z.EncBinaryMarshal(x.Expiration)
-						} else if !yym24 && z.IsJSONHandle() {
-							z.EncJSONMarshal(x.Expiration)
+						if x.Expiration == nil {
+							r.EncodeNil()
 						} else {
-							z.EncFallback(x.Expiration)
+							yym24 := z.EncBinary()
+							_ = yym24
+							if false {
+							} else if yym25 := z.TimeRtidIfBinc(); yym25 != 0 {
+								r.EncodeBuiltin(yym25, x.Expiration)
+							} else if z.HasExtensions() && z.EncExt(x.Expiration) {
+							} else if yym24 {
+								z.EncBinaryMarshal(x.Expiration)
+							} else if !yym24 && z.IsJSONHandle() {
+								z.EncJSONMarshal(x.Expiration)
+							} else {
+								z.EncFallback(x.Expiration)
+							}
 						}
 					}
 				}
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayElem1819)
+				r.WriteArrayElem()
 				if yyq2[7] {
 					yym27 := z.EncBinary()
 					_ = yym27
@@ -533,9 +2380,9 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 				}
 			} else {
 				if yyq2[7] {
-					z.EncSendContainerState(codecSelfer_containerMapKey1819)
-					r.EncodeString(codecSelferC_UTF81819, string("ttl"))
-					z.EncSendContainerState(codecSelfer_containerMapValue1819)
+					r.WriteMapElemKey()
+					r.EncodeString(codecSelferC_UTF87612, string("ttl"))
+					r.WriteMapElemValue()
 					yym28 := z.EncBinary()
 					_ = yym28
 					if false {
@@ -545,16 +2392,16 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 				}
 			}
 			if yyr2 || yy2arr2 {
-				z.EncSendContainerState(codecSelfer_containerArrayEnd1819)
+				r.WriteArrayEnd()
 			} else {
-				z.EncSendContainerState(codecSelfer_containerMapEnd1819)
+				r.WriteMapEnd()
 			}
 		}
 	}
 }
 
 func (x *Node) CodecDecodeSelf(d *codec1978.Decoder) {
-	var h codecSelfer1819
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperDecoder(d)
 	_, _, _ = h, z, r
 	yym1 := z.DecBinary()
@@ -563,28 +2410,28 @@ func (x *Node) CodecDecodeSelf(d *codec1978.Decoder) {
 	} else if z.HasExtensions() && z.DecExt(x) {
 	} else {
 		yyct2 := r.ContainerType()
-		if yyct2 == codecSelferValueTypeMap1819 {
+		if yyct2 == codecSelferValueTypeMap7612 {
 			yyl2 := r.ReadMapStart()
 			if yyl2 == 0 {
-				z.DecSendContainerState(codecSelfer_containerMapEnd1819)
+				r.ReadMapEnd()
 			} else {
 				x.codecDecodeSelfFromMap(yyl2, d)
 			}
-		} else if yyct2 == codecSelferValueTypeArray1819 {
+		} else if yyct2 == codecSelferValueTypeArray7612 {
 			yyl2 := r.ReadArrayStart()
 			if yyl2 == 0 {
-				z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+				r.ReadArrayEnd()
 			} else {
 				x.codecDecodeSelfFromArray(yyl2, d)
 			}
 		} else {
-			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1819)
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
 		}
 	}
 }
 
 func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
-	var h codecSelfer1819
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperDecoder(d)
 	_, _, _ = h, z, r
 	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
@@ -600,10 +2447,10 @@ func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 				break
 			}
 		}
-		z.DecSendContainerState(codecSelfer_containerMapKey1819)
-		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
 		yys3 := string(yys3Slc)
-		z.DecSendContainerState(codecSelfer_containerMapValue1819)
+		r.ReadMapElemValue()
 		switch yys3 {
 		case "key":
 			if r.TryDecodeAsNil() {
@@ -673,6 +2520,9 @@ func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 				}
 			}
 		case "expiration":
+			if x.Expiration == nil {
+				x.Expiration = new(time.Time)
+			}
 			if r.TryDecodeAsNil() {
 				if x.Expiration != nil {
 					x.Expiration = nil
@@ -711,11 +2561,11 @@ func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 			z.DecStructFieldNotFound(-1, yys3)
 		} // end switch yys3
 	} // end for yyj3
-	z.DecSendContainerState(codecSelfer_containerMapEnd1819)
+	r.ReadMapEnd()
 }
 
 func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
-	var h codecSelfer1819
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperDecoder(d)
 	_, _, _ = h, z, r
 	var yyj20 int
@@ -728,10 +2578,10 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb20 = r.CheckBreak()
 	}
 	if yyb20 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		x.Key = ""
 	} else {
@@ -750,10 +2600,10 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb20 = r.CheckBreak()
 	}
 	if yyb20 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		x.Dir = false
 	} else {
@@ -772,10 +2622,10 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb20 = r.CheckBreak()
 	}
 	if yyb20 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		x.Value = ""
 	} else {
@@ -794,10 +2644,10 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb20 = r.CheckBreak()
 	}
 	if yyb20 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		x.Nodes = nil
 	} else {
@@ -811,10 +2661,10 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb20 = r.CheckBreak()
 	}
 	if yyb20 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		x.CreatedIndex = 0
 	} else {
@@ -833,10 +2683,10 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb20 = r.CheckBreak()
 	}
 	if yyb20 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		x.ModifiedIndex = 0
 	} else {
@@ -848,6 +2698,9 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 			*((*uint64)(yyv30)) = uint64(r.DecodeUint(64))
 		}
 	}
+	if x.Expiration == nil {
+		x.Expiration = new(time.Time)
+	}
 	yyj20++
 	if yyhl20 {
 		yyb20 = yyj20 > l
@@ -855,10 +2708,10 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb20 = r.CheckBreak()
 	}
 	if yyb20 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		if x.Expiration != nil {
 			x.Expiration = nil
@@ -888,10 +2741,10 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		yyb20 = r.CheckBreak()
 	}
 	if yyb20 {
-		z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+		r.ReadArrayEnd()
 		return
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+	r.ReadArrayElem()
 	if r.TryDecodeAsNil() {
 		x.TTL = 0
 	} else {
@@ -913,14 +2766,14 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 		if yyb20 {
 			break
 		}
-		z.DecSendContainerState(codecSelfer_containerArrayElem1819)
+		r.ReadArrayElem()
 		z.DecStructFieldNotFound(yyj20-1, "")
 	}
-	z.DecSendContainerState(codecSelfer_containerArrayEnd1819)
+	r.ReadArrayEnd()
 }
 
 func (x Nodes) CodecEncodeSelf(e *codec1978.Encoder) {
-	var h codecSelfer1819
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperEncoder(e)
 	_, _, _ = h, z, r
 	if x == nil {
@@ -937,7 +2790,7 @@ func (x Nodes) CodecEncodeSelf(e *codec1978.Encoder) {
 }
 
 func (x *Nodes) CodecDecodeSelf(d *codec1978.Decoder) {
-	var h codecSelfer1819
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperDecoder(d)
 	_, _, _ = h, z, r
 	yym1 := z.DecBinary()
@@ -949,24 +2802,2333 @@ func (x *Nodes) CodecDecodeSelf(d *codec1978.Decoder) {
 	}
 }
 
-func (x codecSelfer1819) encNodes(v Nodes, e *codec1978.Encoder) {
-	var h codecSelfer1819
+func (x *httpKeysAPI) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperEncoder(e)
 	_, _, _ = h, z, r
-	r.EncodeArrayStart(len(v))
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(0)
+			} else {
+				r.WriteMapStart(0)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *httpKeysAPI) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *httpKeysAPI) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *httpKeysAPI) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj4 int
+	var yyb4 bool
+	var yyhl4 bool = l >= 0
+	for {
+		yyj4++
+		if yyhl4 {
+			yyb4 = yyj4 > l
+		} else {
+			yyb4 = r.CheckBreak()
+		}
+		if yyb4 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj4-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *httpWatcher) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(0)
+			} else {
+				r.WriteMapStart(0)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *httpWatcher) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *httpWatcher) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *httpWatcher) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj4 int
+	var yyb4 bool
+	var yyhl4 bool = l >= 0
+	for {
+		yyj4++
+		if yyhl4 {
+			yyb4 = yyj4 > l
+		} else {
+			yyb4 = r.CheckBreak()
+		}
+		if yyb4 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj4-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *getAction) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(5)
+			} else {
+				r.WriteMapStart(5)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Prefix))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Prefix"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Prefix))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym7 := z.EncBinary()
+				_ = yym7
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Key))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Key"))
+				r.WriteMapElemValue()
+				yym8 := z.EncBinary()
+				_ = yym8
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Key))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym10 := z.EncBinary()
+				_ = yym10
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Recursive"))
+				r.WriteMapElemValue()
+				yym11 := z.EncBinary()
+				_ = yym11
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym13 := z.EncBinary()
+				_ = yym13
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Sorted))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Sorted"))
+				r.WriteMapElemValue()
+				yym14 := z.EncBinary()
+				_ = yym14
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Sorted))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym16 := z.EncBinary()
+				_ = yym16
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Quorum))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Quorum"))
+				r.WriteMapElemValue()
+				yym17 := z.EncBinary()
+				_ = yym17
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Quorum))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *getAction) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *getAction) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "Prefix":
+			if r.TryDecodeAsNil() {
+				x.Prefix = ""
+			} else {
+				yyv4 := &x.Prefix
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else {
+					*((*string)(yyv4)) = r.DecodeString()
+				}
+			}
+		case "Key":
+			if r.TryDecodeAsNil() {
+				x.Key = ""
+			} else {
+				yyv6 := &x.Key
+				yym7 := z.DecBinary()
+				_ = yym7
+				if false {
+				} else {
+					*((*string)(yyv6)) = r.DecodeString()
+				}
+			}
+		case "Recursive":
+			if r.TryDecodeAsNil() {
+				x.Recursive = false
+			} else {
+				yyv8 := &x.Recursive
+				yym9 := z.DecBinary()
+				_ = yym9
+				if false {
+				} else {
+					*((*bool)(yyv8)) = r.DecodeBool()
+				}
+			}
+		case "Sorted":
+			if r.TryDecodeAsNil() {
+				x.Sorted = false
+			} else {
+				yyv10 := &x.Sorted
+				yym11 := z.DecBinary()
+				_ = yym11
+				if false {
+				} else {
+					*((*bool)(yyv10)) = r.DecodeBool()
+				}
+			}
+		case "Quorum":
+			if r.TryDecodeAsNil() {
+				x.Quorum = false
+			} else {
+				yyv12 := &x.Quorum
+				yym13 := z.DecBinary()
+				_ = yym13
+				if false {
+				} else {
+					*((*bool)(yyv12)) = r.DecodeBool()
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *getAction) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj14 int
+	var yyb14 bool
+	var yyhl14 bool = l >= 0
+	yyj14++
+	if yyhl14 {
+		yyb14 = yyj14 > l
+	} else {
+		yyb14 = r.CheckBreak()
+	}
+	if yyb14 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Prefix = ""
+	} else {
+		yyv15 := &x.Prefix
+		yym16 := z.DecBinary()
+		_ = yym16
+		if false {
+		} else {
+			*((*string)(yyv15)) = r.DecodeString()
+		}
+	}
+	yyj14++
+	if yyhl14 {
+		yyb14 = yyj14 > l
+	} else {
+		yyb14 = r.CheckBreak()
+	}
+	if yyb14 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Key = ""
+	} else {
+		yyv17 := &x.Key
+		yym18 := z.DecBinary()
+		_ = yym18
+		if false {
+		} else {
+			*((*string)(yyv17)) = r.DecodeString()
+		}
+	}
+	yyj14++
+	if yyhl14 {
+		yyb14 = yyj14 > l
+	} else {
+		yyb14 = r.CheckBreak()
+	}
+	if yyb14 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Recursive = false
+	} else {
+		yyv19 := &x.Recursive
+		yym20 := z.DecBinary()
+		_ = yym20
+		if false {
+		} else {
+			*((*bool)(yyv19)) = r.DecodeBool()
+		}
+	}
+	yyj14++
+	if yyhl14 {
+		yyb14 = yyj14 > l
+	} else {
+		yyb14 = r.CheckBreak()
+	}
+	if yyb14 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Sorted = false
+	} else {
+		yyv21 := &x.Sorted
+		yym22 := z.DecBinary()
+		_ = yym22
+		if false {
+		} else {
+			*((*bool)(yyv21)) = r.DecodeBool()
+		}
+	}
+	yyj14++
+	if yyhl14 {
+		yyb14 = yyj14 > l
+	} else {
+		yyb14 = r.CheckBreak()
+	}
+	if yyb14 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Quorum = false
+	} else {
+		yyv23 := &x.Quorum
+		yym24 := z.DecBinary()
+		_ = yym24
+		if false {
+		} else {
+			*((*bool)(yyv23)) = r.DecodeBool()
+		}
+	}
+	for {
+		yyj14++
+		if yyhl14 {
+			yyb14 = yyj14 > l
+		} else {
+			yyb14 = r.CheckBreak()
+		}
+		if yyb14 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj14-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *waitAction) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(4)
+			} else {
+				r.WriteMapStart(4)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Prefix))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Prefix"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Prefix))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym7 := z.EncBinary()
+				_ = yym7
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Key))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Key"))
+				r.WriteMapElemValue()
+				yym8 := z.EncBinary()
+				_ = yym8
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Key))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym10 := z.EncBinary()
+				_ = yym10
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.WaitIndex))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("WaitIndex"))
+				r.WriteMapElemValue()
+				yym11 := z.EncBinary()
+				_ = yym11
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.WaitIndex))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym13 := z.EncBinary()
+				_ = yym13
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Recursive"))
+				r.WriteMapElemValue()
+				yym14 := z.EncBinary()
+				_ = yym14
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *waitAction) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *waitAction) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "Prefix":
+			if r.TryDecodeAsNil() {
+				x.Prefix = ""
+			} else {
+				yyv4 := &x.Prefix
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else {
+					*((*string)(yyv4)) = r.DecodeString()
+				}
+			}
+		case "Key":
+			if r.TryDecodeAsNil() {
+				x.Key = ""
+			} else {
+				yyv6 := &x.Key
+				yym7 := z.DecBinary()
+				_ = yym7
+				if false {
+				} else {
+					*((*string)(yyv6)) = r.DecodeString()
+				}
+			}
+		case "WaitIndex":
+			if r.TryDecodeAsNil() {
+				x.WaitIndex = 0
+			} else {
+				yyv8 := &x.WaitIndex
+				yym9 := z.DecBinary()
+				_ = yym9
+				if false {
+				} else {
+					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
+				}
+			}
+		case "Recursive":
+			if r.TryDecodeAsNil() {
+				x.Recursive = false
+			} else {
+				yyv10 := &x.Recursive
+				yym11 := z.DecBinary()
+				_ = yym11
+				if false {
+				} else {
+					*((*bool)(yyv10)) = r.DecodeBool()
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *waitAction) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj12 int
+	var yyb12 bool
+	var yyhl12 bool = l >= 0
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Prefix = ""
+	} else {
+		yyv13 := &x.Prefix
+		yym14 := z.DecBinary()
+		_ = yym14
+		if false {
+		} else {
+			*((*string)(yyv13)) = r.DecodeString()
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Key = ""
+	} else {
+		yyv15 := &x.Key
+		yym16 := z.DecBinary()
+		_ = yym16
+		if false {
+		} else {
+			*((*string)(yyv15)) = r.DecodeString()
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.WaitIndex = 0
+	} else {
+		yyv17 := &x.WaitIndex
+		yym18 := z.DecBinary()
+		_ = yym18
+		if false {
+		} else {
+			*((*uint64)(yyv17)) = uint64(r.DecodeUint(64))
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Recursive = false
+	} else {
+		yyv19 := &x.Recursive
+		yym20 := z.DecBinary()
+		_ = yym20
+		if false {
+		} else {
+			*((*bool)(yyv19)) = r.DecodeBool()
+		}
+	}
+	for {
+		yyj12++
+		if yyhl12 {
+			yyb12 = yyj12 > l
+		} else {
+			yyb12 = r.CheckBreak()
+		}
+		if yyb12 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj12-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *setAction) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(10)
+			} else {
+				r.WriteMapStart(10)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Prefix))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Prefix"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Prefix))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym7 := z.EncBinary()
+				_ = yym7
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Key))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Key"))
+				r.WriteMapElemValue()
+				yym8 := z.EncBinary()
+				_ = yym8
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Key))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym10 := z.EncBinary()
+				_ = yym10
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Value))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Value"))
+				r.WriteMapElemValue()
+				yym11 := z.EncBinary()
+				_ = yym11
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Value))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym13 := z.EncBinary()
+				_ = yym13
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.PrevValue))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("PrevValue"))
+				r.WriteMapElemValue()
+				yym14 := z.EncBinary()
+				_ = yym14
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.PrevValue))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym16 := z.EncBinary()
+				_ = yym16
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.PrevIndex))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("PrevIndex"))
+				r.WriteMapElemValue()
+				yym17 := z.EncBinary()
+				_ = yym17
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.PrevIndex))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				x.PrevExist.CodecEncodeSelf(e)
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("PrevExist"))
+				r.WriteMapElemValue()
+				x.PrevExist.CodecEncodeSelf(e)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym22 := z.EncBinary()
+				_ = yym22
+				if false {
+				} else if z.HasExtensions() && z.EncExt(x.TTL) {
+				} else {
+					r.EncodeInt(int64(x.TTL))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("TTL"))
+				r.WriteMapElemValue()
+				yym23 := z.EncBinary()
+				_ = yym23
+				if false {
+				} else if z.HasExtensions() && z.EncExt(x.TTL) {
+				} else {
+					r.EncodeInt(int64(x.TTL))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym25 := z.EncBinary()
+				_ = yym25
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Refresh))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Refresh"))
+				r.WriteMapElemValue()
+				yym26 := z.EncBinary()
+				_ = yym26
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Refresh))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym28 := z.EncBinary()
+				_ = yym28
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Dir))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Dir"))
+				r.WriteMapElemValue()
+				yym29 := z.EncBinary()
+				_ = yym29
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Dir))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym31 := z.EncBinary()
+				_ = yym31
+				if false {
+				} else {
+					r.EncodeBool(bool(x.NoValueOnSuccess))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("NoValueOnSuccess"))
+				r.WriteMapElemValue()
+				yym32 := z.EncBinary()
+				_ = yym32
+				if false {
+				} else {
+					r.EncodeBool(bool(x.NoValueOnSuccess))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *setAction) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *setAction) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "Prefix":
+			if r.TryDecodeAsNil() {
+				x.Prefix = ""
+			} else {
+				yyv4 := &x.Prefix
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else {
+					*((*string)(yyv4)) = r.DecodeString()
+				}
+			}
+		case "Key":
+			if r.TryDecodeAsNil() {
+				x.Key = ""
+			} else {
+				yyv6 := &x.Key
+				yym7 := z.DecBinary()
+				_ = yym7
+				if false {
+				} else {
+					*((*string)(yyv6)) = r.DecodeString()
+				}
+			}
+		case "Value":
+			if r.TryDecodeAsNil() {
+				x.Value = ""
+			} else {
+				yyv8 := &x.Value
+				yym9 := z.DecBinary()
+				_ = yym9
+				if false {
+				} else {
+					*((*string)(yyv8)) = r.DecodeString()
+				}
+			}
+		case "PrevValue":
+			if r.TryDecodeAsNil() {
+				x.PrevValue = ""
+			} else {
+				yyv10 := &x.PrevValue
+				yym11 := z.DecBinary()
+				_ = yym11
+				if false {
+				} else {
+					*((*string)(yyv10)) = r.DecodeString()
+				}
+			}
+		case "PrevIndex":
+			if r.TryDecodeAsNil() {
+				x.PrevIndex = 0
+			} else {
+				yyv12 := &x.PrevIndex
+				yym13 := z.DecBinary()
+				_ = yym13
+				if false {
+				} else {
+					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
+				}
+			}
+		case "PrevExist":
+			if r.TryDecodeAsNil() {
+				x.PrevExist = ""
+			} else {
+				yyv14 := &x.PrevExist
+				yyv14.CodecDecodeSelf(d)
+			}
+		case "TTL":
+			if r.TryDecodeAsNil() {
+				x.TTL = 0
+			} else {
+				yyv15 := &x.TTL
+				yym16 := z.DecBinary()
+				_ = yym16
+				if false {
+				} else if z.HasExtensions() && z.DecExt(yyv15) {
+				} else {
+					*((*int64)(yyv15)) = int64(r.DecodeInt(64))
+				}
+			}
+		case "Refresh":
+			if r.TryDecodeAsNil() {
+				x.Refresh = false
+			} else {
+				yyv17 := &x.Refresh
+				yym18 := z.DecBinary()
+				_ = yym18
+				if false {
+				} else {
+					*((*bool)(yyv17)) = r.DecodeBool()
+				}
+			}
+		case "Dir":
+			if r.TryDecodeAsNil() {
+				x.Dir = false
+			} else {
+				yyv19 := &x.Dir
+				yym20 := z.DecBinary()
+				_ = yym20
+				if false {
+				} else {
+					*((*bool)(yyv19)) = r.DecodeBool()
+				}
+			}
+		case "NoValueOnSuccess":
+			if r.TryDecodeAsNil() {
+				x.NoValueOnSuccess = false
+			} else {
+				yyv21 := &x.NoValueOnSuccess
+				yym22 := z.DecBinary()
+				_ = yym22
+				if false {
+				} else {
+					*((*bool)(yyv21)) = r.DecodeBool()
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *setAction) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj23 int
+	var yyb23 bool
+	var yyhl23 bool = l >= 0
+	yyj23++
+	if yyhl23 {
+		yyb23 = yyj23 > l
+	} else {
+		yyb23 = r.CheckBreak()
+	}
+	if yyb23 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Prefix = ""
+	} else {
+		yyv24 := &x.Prefix
+		yym25 := z.DecBinary()
+		_ = yym25
+		if false {
+		} else {
+			*((*string)(yyv24)) = r.DecodeString()
+		}
+	}
+	yyj23++
+	if yyhl23 {
+		yyb23 = yyj23 > l
+	} else {
+		yyb23 = r.CheckBreak()
+	}
+	if yyb23 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Key = ""
+	} else {
+		yyv26 := &x.Key
+		yym27 := z.DecBinary()
+		_ = yym27
+		if false {
+		} else {
+			*((*string)(yyv26)) = r.DecodeString()
+		}
+	}
+	yyj23++
+	if yyhl23 {
+		yyb23 = yyj23 > l
+	} else {
+		yyb23 = r.CheckBreak()
+	}
+	if yyb23 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Value = ""
+	} else {
+		yyv28 := &x.Value
+		yym29 := z.DecBinary()
+		_ = yym29
+		if false {
+		} else {
+			*((*string)(yyv28)) = r.DecodeString()
+		}
+	}
+	yyj23++
+	if yyhl23 {
+		yyb23 = yyj23 > l
+	} else {
+		yyb23 = r.CheckBreak()
+	}
+	if yyb23 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.PrevValue = ""
+	} else {
+		yyv30 := &x.PrevValue
+		yym31 := z.DecBinary()
+		_ = yym31
+		if false {
+		} else {
+			*((*string)(yyv30)) = r.DecodeString()
+		}
+	}
+	yyj23++
+	if yyhl23 {
+		yyb23 = yyj23 > l
+	} else {
+		yyb23 = r.CheckBreak()
+	}
+	if yyb23 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.PrevIndex = 0
+	} else {
+		yyv32 := &x.PrevIndex
+		yym33 := z.DecBinary()
+		_ = yym33
+		if false {
+		} else {
+			*((*uint64)(yyv32)) = uint64(r.DecodeUint(64))
+		}
+	}
+	yyj23++
+	if yyhl23 {
+		yyb23 = yyj23 > l
+	} else {
+		yyb23 = r.CheckBreak()
+	}
+	if yyb23 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.PrevExist = ""
+	} else {
+		yyv34 := &x.PrevExist
+		yyv34.CodecDecodeSelf(d)
+	}
+	yyj23++
+	if yyhl23 {
+		yyb23 = yyj23 > l
+	} else {
+		yyb23 = r.CheckBreak()
+	}
+	if yyb23 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.TTL = 0
+	} else {
+		yyv35 := &x.TTL
+		yym36 := z.DecBinary()
+		_ = yym36
+		if false {
+		} else if z.HasExtensions() && z.DecExt(yyv35) {
+		} else {
+			*((*int64)(yyv35)) = int64(r.DecodeInt(64))
+		}
+	}
+	yyj23++
+	if yyhl23 {
+		yyb23 = yyj23 > l
+	} else {
+		yyb23 = r.CheckBreak()
+	}
+	if yyb23 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Refresh = false
+	} else {
+		yyv37 := &x.Refresh
+		yym38 := z.DecBinary()
+		_ = yym38
+		if false {
+		} else {
+			*((*bool)(yyv37)) = r.DecodeBool()
+		}
+	}
+	yyj23++
+	if yyhl23 {
+		yyb23 = yyj23 > l
+	} else {
+		yyb23 = r.CheckBreak()
+	}
+	if yyb23 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Dir = false
+	} else {
+		yyv39 := &x.Dir
+		yym40 := z.DecBinary()
+		_ = yym40
+		if false {
+		} else {
+			*((*bool)(yyv39)) = r.DecodeBool()
+		}
+	}
+	yyj23++
+	if yyhl23 {
+		yyb23 = yyj23 > l
+	} else {
+		yyb23 = r.CheckBreak()
+	}
+	if yyb23 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.NoValueOnSuccess = false
+	} else {
+		yyv41 := &x.NoValueOnSuccess
+		yym42 := z.DecBinary()
+		_ = yym42
+		if false {
+		} else {
+			*((*bool)(yyv41)) = r.DecodeBool()
+		}
+	}
+	for {
+		yyj23++
+		if yyhl23 {
+			yyb23 = yyj23 > l
+		} else {
+			yyb23 = r.CheckBreak()
+		}
+		if yyb23 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj23-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *deleteAction) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(6)
+			} else {
+				r.WriteMapStart(6)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Prefix))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Prefix"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Prefix))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym7 := z.EncBinary()
+				_ = yym7
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Key))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Key"))
+				r.WriteMapElemValue()
+				yym8 := z.EncBinary()
+				_ = yym8
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Key))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym10 := z.EncBinary()
+				_ = yym10
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.PrevValue))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("PrevValue"))
+				r.WriteMapElemValue()
+				yym11 := z.EncBinary()
+				_ = yym11
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.PrevValue))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym13 := z.EncBinary()
+				_ = yym13
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.PrevIndex))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("PrevIndex"))
+				r.WriteMapElemValue()
+				yym14 := z.EncBinary()
+				_ = yym14
+				if false {
+				} else {
+					r.EncodeUint(uint64(x.PrevIndex))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym16 := z.EncBinary()
+				_ = yym16
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Dir))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Dir"))
+				r.WriteMapElemValue()
+				yym17 := z.EncBinary()
+				_ = yym17
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Dir))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym19 := z.EncBinary()
+				_ = yym19
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Recursive"))
+				r.WriteMapElemValue()
+				yym20 := z.EncBinary()
+				_ = yym20
+				if false {
+				} else {
+					r.EncodeBool(bool(x.Recursive))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *deleteAction) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *deleteAction) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "Prefix":
+			if r.TryDecodeAsNil() {
+				x.Prefix = ""
+			} else {
+				yyv4 := &x.Prefix
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else {
+					*((*string)(yyv4)) = r.DecodeString()
+				}
+			}
+		case "Key":
+			if r.TryDecodeAsNil() {
+				x.Key = ""
+			} else {
+				yyv6 := &x.Key
+				yym7 := z.DecBinary()
+				_ = yym7
+				if false {
+				} else {
+					*((*string)(yyv6)) = r.DecodeString()
+				}
+			}
+		case "PrevValue":
+			if r.TryDecodeAsNil() {
+				x.PrevValue = ""
+			} else {
+				yyv8 := &x.PrevValue
+				yym9 := z.DecBinary()
+				_ = yym9
+				if false {
+				} else {
+					*((*string)(yyv8)) = r.DecodeString()
+				}
+			}
+		case "PrevIndex":
+			if r.TryDecodeAsNil() {
+				x.PrevIndex = 0
+			} else {
+				yyv10 := &x.PrevIndex
+				yym11 := z.DecBinary()
+				_ = yym11
+				if false {
+				} else {
+					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
+				}
+			}
+		case "Dir":
+			if r.TryDecodeAsNil() {
+				x.Dir = false
+			} else {
+				yyv12 := &x.Dir
+				yym13 := z.DecBinary()
+				_ = yym13
+				if false {
+				} else {
+					*((*bool)(yyv12)) = r.DecodeBool()
+				}
+			}
+		case "Recursive":
+			if r.TryDecodeAsNil() {
+				x.Recursive = false
+			} else {
+				yyv14 := &x.Recursive
+				yym15 := z.DecBinary()
+				_ = yym15
+				if false {
+				} else {
+					*((*bool)(yyv14)) = r.DecodeBool()
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *deleteAction) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj16 int
+	var yyb16 bool
+	var yyhl16 bool = l >= 0
+	yyj16++
+	if yyhl16 {
+		yyb16 = yyj16 > l
+	} else {
+		yyb16 = r.CheckBreak()
+	}
+	if yyb16 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Prefix = ""
+	} else {
+		yyv17 := &x.Prefix
+		yym18 := z.DecBinary()
+		_ = yym18
+		if false {
+		} else {
+			*((*string)(yyv17)) = r.DecodeString()
+		}
+	}
+	yyj16++
+	if yyhl16 {
+		yyb16 = yyj16 > l
+	} else {
+		yyb16 = r.CheckBreak()
+	}
+	if yyb16 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Key = ""
+	} else {
+		yyv19 := &x.Key
+		yym20 := z.DecBinary()
+		_ = yym20
+		if false {
+		} else {
+			*((*string)(yyv19)) = r.DecodeString()
+		}
+	}
+	yyj16++
+	if yyhl16 {
+		yyb16 = yyj16 > l
+	} else {
+		yyb16 = r.CheckBreak()
+	}
+	if yyb16 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.PrevValue = ""
+	} else {
+		yyv21 := &x.PrevValue
+		yym22 := z.DecBinary()
+		_ = yym22
+		if false {
+		} else {
+			*((*string)(yyv21)) = r.DecodeString()
+		}
+	}
+	yyj16++
+	if yyhl16 {
+		yyb16 = yyj16 > l
+	} else {
+		yyb16 = r.CheckBreak()
+	}
+	if yyb16 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.PrevIndex = 0
+	} else {
+		yyv23 := &x.PrevIndex
+		yym24 := z.DecBinary()
+		_ = yym24
+		if false {
+		} else {
+			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
+		}
+	}
+	yyj16++
+	if yyhl16 {
+		yyb16 = yyj16 > l
+	} else {
+		yyb16 = r.CheckBreak()
+	}
+	if yyb16 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Dir = false
+	} else {
+		yyv25 := &x.Dir
+		yym26 := z.DecBinary()
+		_ = yym26
+		if false {
+		} else {
+			*((*bool)(yyv25)) = r.DecodeBool()
+		}
+	}
+	yyj16++
+	if yyhl16 {
+		yyb16 = yyj16 > l
+	} else {
+		yyb16 = r.CheckBreak()
+	}
+	if yyb16 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Recursive = false
+	} else {
+		yyv27 := &x.Recursive
+		yym28 := z.DecBinary()
+		_ = yym28
+		if false {
+		} else {
+			*((*bool)(yyv27)) = r.DecodeBool()
+		}
+	}
+	for {
+		yyj16++
+		if yyhl16 {
+			yyb16 = yyj16 > l
+		} else {
+			yyb16 = r.CheckBreak()
+		}
+		if yyb16 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj16-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x *createInOrderAction) CodecEncodeSelf(e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	if x == nil {
+		r.EncodeNil()
+	} else {
+		yym1 := z.EncBinary()
+		_ = yym1
+		if false {
+		} else if z.HasExtensions() && z.EncExt(x) {
+		} else {
+			yysep2 := !z.EncBinary()
+			yy2arr2 := z.EncBasicHandle().StructToArray
+			_, _ = yysep2, yy2arr2
+			const yyr2 bool = false
+			if yyr2 || yy2arr2 {
+				r.WriteArrayStart(4)
+			} else {
+				r.WriteMapStart(4)
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym4 := z.EncBinary()
+				_ = yym4
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Prefix))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Prefix"))
+				r.WriteMapElemValue()
+				yym5 := z.EncBinary()
+				_ = yym5
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Prefix))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym7 := z.EncBinary()
+				_ = yym7
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Dir))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Dir"))
+				r.WriteMapElemValue()
+				yym8 := z.EncBinary()
+				_ = yym8
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Dir))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym10 := z.EncBinary()
+				_ = yym10
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Value))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("Value"))
+				r.WriteMapElemValue()
+				yym11 := z.EncBinary()
+				_ = yym11
+				if false {
+				} else {
+					r.EncodeString(codecSelferC_UTF87612, string(x.Value))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayElem()
+				yym13 := z.EncBinary()
+				_ = yym13
+				if false {
+				} else if z.HasExtensions() && z.EncExt(x.TTL) {
+				} else {
+					r.EncodeInt(int64(x.TTL))
+				}
+			} else {
+				r.WriteMapElemKey()
+				r.EncodeString(codecSelferC_UTF87612, string("TTL"))
+				r.WriteMapElemValue()
+				yym14 := z.EncBinary()
+				_ = yym14
+				if false {
+				} else if z.HasExtensions() && z.EncExt(x.TTL) {
+				} else {
+					r.EncodeInt(int64(x.TTL))
+				}
+			}
+			if yyr2 || yy2arr2 {
+				r.WriteArrayEnd()
+			} else {
+				r.WriteMapEnd()
+			}
+		}
+	}
+}
+
+func (x *createInOrderAction) CodecDecodeSelf(d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	yym1 := z.DecBinary()
+	_ = yym1
+	if false {
+	} else if z.HasExtensions() && z.DecExt(x) {
+	} else {
+		yyct2 := r.ContainerType()
+		if yyct2 == codecSelferValueTypeMap7612 {
+			yyl2 := r.ReadMapStart()
+			if yyl2 == 0 {
+				r.ReadMapEnd()
+			} else {
+				x.codecDecodeSelfFromMap(yyl2, d)
+			}
+		} else if yyct2 == codecSelferValueTypeArray7612 {
+			yyl2 := r.ReadArrayStart()
+			if yyl2 == 0 {
+				r.ReadArrayEnd()
+			} else {
+				x.codecDecodeSelfFromArray(yyl2, d)
+			}
+		} else {
+			panic(codecSelferOnlyMapOrArrayEncodeToStructErr7612)
+		}
+	}
+}
+
+func (x *createInOrderAction) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+	_ = yys3Slc
+	var yyhl3 bool = l >= 0
+	for yyj3 := 0; ; yyj3++ {
+		if yyhl3 {
+			if yyj3 >= l {
+				break
+			}
+		} else {
+			if r.CheckBreak() {
+				break
+			}
+		}
+		r.ReadMapElemKey()
+		yys3Slc = r.DecodeStringAsBytes()
+		yys3 := string(yys3Slc)
+		r.ReadMapElemValue()
+		switch yys3 {
+		case "Prefix":
+			if r.TryDecodeAsNil() {
+				x.Prefix = ""
+			} else {
+				yyv4 := &x.Prefix
+				yym5 := z.DecBinary()
+				_ = yym5
+				if false {
+				} else {
+					*((*string)(yyv4)) = r.DecodeString()
+				}
+			}
+		case "Dir":
+			if r.TryDecodeAsNil() {
+				x.Dir = ""
+			} else {
+				yyv6 := &x.Dir
+				yym7 := z.DecBinary()
+				_ = yym7
+				if false {
+				} else {
+					*((*string)(yyv6)) = r.DecodeString()
+				}
+			}
+		case "Value":
+			if r.TryDecodeAsNil() {
+				x.Value = ""
+			} else {
+				yyv8 := &x.Value
+				yym9 := z.DecBinary()
+				_ = yym9
+				if false {
+				} else {
+					*((*string)(yyv8)) = r.DecodeString()
+				}
+			}
+		case "TTL":
+			if r.TryDecodeAsNil() {
+				x.TTL = 0
+			} else {
+				yyv10 := &x.TTL
+				yym11 := z.DecBinary()
+				_ = yym11
+				if false {
+				} else if z.HasExtensions() && z.DecExt(yyv10) {
+				} else {
+					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
+				}
+			}
+		default:
+			z.DecStructFieldNotFound(-1, yys3)
+		} // end switch yys3
+	} // end for yyj3
+	r.ReadMapEnd()
+}
+
+func (x *createInOrderAction) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperDecoder(d)
+	_, _, _ = h, z, r
+	var yyj12 int
+	var yyb12 bool
+	var yyhl12 bool = l >= 0
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Prefix = ""
+	} else {
+		yyv13 := &x.Prefix
+		yym14 := z.DecBinary()
+		_ = yym14
+		if false {
+		} else {
+			*((*string)(yyv13)) = r.DecodeString()
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Dir = ""
+	} else {
+		yyv15 := &x.Dir
+		yym16 := z.DecBinary()
+		_ = yym16
+		if false {
+		} else {
+			*((*string)(yyv15)) = r.DecodeString()
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.Value = ""
+	} else {
+		yyv17 := &x.Value
+		yym18 := z.DecBinary()
+		_ = yym18
+		if false {
+		} else {
+			*((*string)(yyv17)) = r.DecodeString()
+		}
+	}
+	yyj12++
+	if yyhl12 {
+		yyb12 = yyj12 > l
+	} else {
+		yyb12 = r.CheckBreak()
+	}
+	if yyb12 {
+		r.ReadArrayEnd()
+		return
+	}
+	r.ReadArrayElem()
+	if r.TryDecodeAsNil() {
+		x.TTL = 0
+	} else {
+		yyv19 := &x.TTL
+		yym20 := z.DecBinary()
+		_ = yym20
+		if false {
+		} else if z.HasExtensions() && z.DecExt(yyv19) {
+		} else {
+			*((*int64)(yyv19)) = int64(r.DecodeInt(64))
+		}
+	}
+	for {
+		yyj12++
+		if yyhl12 {
+			yyb12 = yyj12 > l
+		} else {
+			yyb12 = r.CheckBreak()
+		}
+		if yyb12 {
+			break
+		}
+		r.ReadArrayElem()
+		z.DecStructFieldNotFound(yyj12-1, "")
+	}
+	r.ReadArrayEnd()
+}
+
+func (x codecSelfer7612) encNodes(v Nodes, e *codec1978.Encoder) {
+	var h codecSelfer7612
+	z, r := codec1978.GenHelperEncoder(e)
+	_, _, _ = h, z, r
+	r.WriteArrayStart(len(v))
 	for _, yyv1 := range v {
-		z.EncSendContainerState(codecSelfer_containerArrayElem1819)
+		r.WriteArrayElem()
 		if yyv1 == nil {
 			r.EncodeNil()
 		} else {
 			yyv1.CodecEncodeSelf(e)
 		}
 	}
-	z.EncSendContainerState(codecSelfer_containerArrayEnd1819)
+	r.WriteArrayEnd()
 }
 
-func (x codecSelfer1819) decNodes(v *Nodes, d *codec1978.Decoder) {
-	var h codecSelfer1819
+func (x codecSelfer7612) decNodes(v *Nodes, d *codec1978.Decoder) {
+	var h codecSelfer7612
 	z, r := codec1978.GenHelperDecoder(d)
 	_, _, _ = h, z, r
 
@@ -982,79 +5144,49 @@ func (x codecSelfer1819) decNodes(v *Nodes, d *codec1978.Decoder) {
 			yyv1 = yyv1[:0]
 			yyc1 = true
 		}
-	} else if yyl1 > 0 {
-		var yyrr1, yyrl1 int
-		var yyrt1 bool
-		_, _ = yyrl1, yyrt1
-		yyrr1 = yyl1 // len(yyv1)
-		if yyl1 > cap(yyv1) {
-
-			yyrg1 := len(yyv1) > 0
-			yyv21 := yyv1
-			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
-			if yyrt1 {
+	} else {
+		yyhl1 := yyl1 > 0
+		var yyrl1 int
+		_ = yyrl1
+		if yyhl1 {
+			if yyl1 > cap(yyv1) {
+				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 				if yyrl1 <= cap(yyv1) {
 					yyv1 = yyv1[:yyrl1]
 				} else {
 					yyv1 = make([]*Node, yyrl1)
 				}
-			} else {
-				yyv1 = make([]*Node, yyrl1)
+				yyc1 = true
+			} else if yyl1 != len(yyv1) {
+				yyv1 = yyv1[:yyl1]
+				yyc1 = true
 			}
-			yyc1 = true
-			yyrr1 = len(yyv1)
-			if yyrg1 {
-				copy(yyv1, yyv21)
-			}
-		} else if yyl1 != len(yyv1) {
-			yyv1 = yyv1[:yyl1]
-			yyc1 = true
 		}
-		yyj1 := 0
-		for ; yyj1 < yyrr1; yyj1++ {
-			yyh1.ElemContainerState(yyj1)
-			if r.TryDecodeAsNil() {
-				if yyv1[yyj1] != nil {
-					*yyv1[yyj1] = Node{}
-				}
-			} else {
-				if yyv1[yyj1] == nil {
-					yyv1[yyj1] = new(Node)
-				}
-				yyw2 := yyv1[yyj1]
-				yyw2.CodecDecodeSelf(d)
-			}
-
-		}
-		if yyrt1 {
-			for ; yyj1 < yyl1; yyj1++ {
-				yyv1 = append(yyv1, nil)
-				yyh1.ElemContainerState(yyj1)
-				if r.TryDecodeAsNil() {
-					if yyv1[yyj1] != nil {
-						*yyv1[yyj1] = Node{}
-					}
+		var yyj1 int
+		// var yydn1 bool
+		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
+			if yyj1 == 0 && len(yyv1) == 0 {
+				if yyhl1 {
+					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 				} else {
-					if yyv1[yyj1] == nil {
-						yyv1[yyj1] = new(Node)
-					}
-					yyw3 := yyv1[yyj1]
-					yyw3.CodecDecodeSelf(d)
+					yyrl1 = 8
 				}
-
-			}
-		}
-
-	} else {
-		yyj1 := 0
-		for ; !r.CheckBreak(); yyj1++ {
-
-			if yyj1 >= len(yyv1) {
-				yyv1 = append(yyv1, nil) // var yyz1 *Node
+				yyv1 = make([]*Node, yyrl1)
 				yyc1 = true
 			}
 			yyh1.ElemContainerState(yyj1)
-			if yyj1 < len(yyv1) {
+			// yydn1 = r.TryDecodeAsNil()
+
+			// if indefinite, etc, then expand the slice if necessary
+			var yydb1 bool
+			if yyj1 >= len(yyv1) {
+				yyv1 = append(yyv1, nil)
+				yyc1 = true
+
+			}
+			if yydb1 {
+				z.DecSwallow()
+			} else {
 				if r.TryDecodeAsNil() {
 					if yyv1[yyj1] != nil {
 						*yyv1[yyj1] = Node{}
@@ -1063,12 +5195,10 @@ func (x codecSelfer1819) decNodes(v *Nodes, d *codec1978.Decoder) {
 					if yyv1[yyj1] == nil {
 						yyv1[yyj1] = new(Node)
 					}
-					yyw4 := yyv1[yyj1]
-					yyw4.CodecDecodeSelf(d)
+					yyw2 := yyv1[yyj1]
+					yyw2.CodecDecodeSelf(d)
 				}
 
-			} else {
-				z.DecSwallow()
 			}
 
 		}
@@ -1076,7 +5206,7 @@ func (x codecSelfer1819) decNodes(v *Nodes, d *codec1978.Decoder) {
 			yyv1 = yyv1[:yyj1]
 			yyc1 = true
 		} else if yyj1 == 0 && yyv1 == nil {
-			yyv1 = []*Node{}
+			yyv1 = make([]*Node, 0)
 			yyc1 = true
 		}
 	}
@@ -1084,4 +5214,5 @@ func (x codecSelfer1819) decNodes(v *Nodes, d *codec1978.Decoder) {
 	if yyc1 {
 		*v = yyv1
 	}
+
 }
diff --git a/vendor/github.com/coreos/etcd/client/keys.go b/vendor/github.com/coreos/etcd/client/keys.go
index 4a6c41a78bc..8b9fd3f87a4 100644
--- a/vendor/github.com/coreos/etcd/client/keys.go
+++ b/vendor/github.com/coreos/etcd/client/keys.go
@@ -17,6 +17,7 @@ package client
 //go:generate codecgen -d 1819 -r "Node|Response|Nodes" -o keys.generated.go keys.go
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -28,7 +29,6 @@ import (
 
 	"github.com/coreos/etcd/pkg/pathutil"
 	"github.com/ugorji/go/codec"
-	"golang.org/x/net/context"
 )
 
 const (
@@ -653,8 +653,7 @@ func unmarshalHTTPResponse(code int, header http.Header, body []byte) (res *Resp
 	default:
 		err = unmarshalFailedKeysResponse(body)
 	}
-
-	return
+	return res, err
 }
 
 func unmarshalSuccessfulKeysResponse(header http.Header, body []byte) (*Response, error) {
diff --git a/vendor/github.com/coreos/etcd/client/members.go b/vendor/github.com/coreos/etcd/client/members.go
index 23adf07ad91..aafa3d1b870 100644
--- a/vendor/github.com/coreos/etcd/client/members.go
+++ b/vendor/github.com/coreos/etcd/client/members.go
@@ -16,14 +16,13 @@ package client
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"net/url"
 	"path"
 
-	"golang.org/x/net/context"
-
 	"github.com/coreos/etcd/pkg/types"
 )
 
@@ -44,7 +43,7 @@ type Member struct {
 	PeerURLs []string `json:"peerURLs"`
 
 	// ClientURLs represents the HTTP(S) endpoints on which this Member
-	// serves it's client-facing APIs.
+	// serves its client-facing APIs.
 	ClientURLs []string `json:"clientURLs"`
 }
 
diff --git a/vendor/github.com/coreos/etcd/clientv3/BUILD b/vendor/github.com/coreos/etcd/clientv3/BUILD
index 6a3b96838a3..bdba6f9db0e 100644
--- a/vendor/github.com/coreos/etcd/clientv3/BUILD
+++ b/vendor/github.com/coreos/etcd/clientv3/BUILD
@@ -32,7 +32,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/etcdserver/etcdserverpb:go_default_library",
         "//vendor/github.com/coreos/etcd/mvcc/mvccpb:go_default_library",
         "//vendor/github.com/coreos/etcd/pkg/types:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
         "//vendor/google.golang.org/grpc:go_default_library",
         "//vendor/google.golang.org/grpc/codes:go_default_library",
         "//vendor/google.golang.org/grpc/credentials:go_default_library",
diff --git a/vendor/github.com/coreos/etcd/clientv3/auth.go b/vendor/github.com/coreos/etcd/clientv3/auth.go
index a64b8caca89..7545bb6ca1c 100644
--- a/vendor/github.com/coreos/etcd/clientv3/auth.go
+++ b/vendor/github.com/coreos/etcd/clientv3/auth.go
@@ -15,13 +15,13 @@
 package clientv3
 
 import (
+	"context"
 	"fmt"
 	"strings"
 
 	"github.com/coreos/etcd/auth/authpb"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
diff --git a/vendor/github.com/coreos/etcd/clientv3/client.go b/vendor/github.com/coreos/etcd/clientv3/client.go
index 5dc93af200a..7132807767e 100644
--- a/vendor/github.com/coreos/etcd/clientv3/client.go
+++ b/vendor/github.com/coreos/etcd/clientv3/client.go
@@ -15,6 +15,7 @@
 package clientv3
 
 import (
+	"context"
 	"crypto/tls"
 	"errors"
 	"fmt"
@@ -27,7 +28,6 @@ import (
 
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials"
diff --git a/vendor/github.com/coreos/etcd/clientv3/cluster.go b/vendor/github.com/coreos/etcd/clientv3/cluster.go
index 93637ddc570..785672be8ca 100644
--- a/vendor/github.com/coreos/etcd/clientv3/cluster.go
+++ b/vendor/github.com/coreos/etcd/clientv3/cluster.go
@@ -15,10 +15,11 @@
 package clientv3
 
 import (
+	"context"
+
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/pkg/types"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
diff --git a/vendor/github.com/coreos/etcd/clientv3/compare.go b/vendor/github.com/coreos/etcd/clientv3/compare.go
index 68a25fd800f..b5f0a255279 100644
--- a/vendor/github.com/coreos/etcd/clientv3/compare.go
+++ b/vendor/github.com/coreos/etcd/clientv3/compare.go
@@ -60,6 +60,8 @@ func Compare(cmp Cmp, result string, v interface{}) Cmp {
 		cmp.TargetUnion = &pb.Compare_CreateRevision{CreateRevision: mustInt64(v)}
 	case pb.Compare_MOD:
 		cmp.TargetUnion = &pb.Compare_ModRevision{ModRevision: mustInt64(v)}
+	case pb.Compare_LEASE:
+		cmp.TargetUnion = &pb.Compare_Lease{Lease: mustInt64orLeaseID(v)}
 	default:
 		panic("Unknown compare type")
 	}
@@ -82,6 +84,12 @@ func ModRevision(key string) Cmp {
 	return Cmp{Key: []byte(key), Target: pb.Compare_MOD}
 }
 
+// LeaseValue compares a key's LeaseID to a value of your choosing. The empty
+// LeaseID is 0, otherwise known as `NoLease`.
+func LeaseValue(key string) Cmp {
+	return Cmp{Key: []byte(key), Target: pb.Compare_LEASE}
+}
+
 // KeyBytes returns the byte slice holding with the comparison key.
 func (cmp *Cmp) KeyBytes() []byte { return cmp.Key }
 
@@ -99,6 +107,18 @@ func (cmp *Cmp) ValueBytes() []byte {
 // WithValueBytes sets the byte slice for the comparison's value.
 func (cmp *Cmp) WithValueBytes(v []byte) { cmp.TargetUnion.(*pb.Compare_Value).Value = v }
 
+// WithRange sets the comparison to scan the range [key, end).
+func (cmp Cmp) WithRange(end string) Cmp {
+	cmp.RangeEnd = []byte(end)
+	return cmp
+}
+
+// WithPrefix sets the comparison to scan all keys prefixed by the key.
+func (cmp Cmp) WithPrefix() Cmp {
+	cmp.RangeEnd = getPrefix(cmp.Key)
+	return cmp
+}
+
 // mustInt64 panics if val isn't an int or int64. It returns an int64 otherwise.
 func mustInt64(val interface{}) int64 {
 	if v, ok := val.(int64); ok {
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/BUILD b/vendor/github.com/coreos/etcd/clientv3/concurrency/BUILD
index 331533b2bdd..2ee68bc9c02 100644
--- a/vendor/github.com/coreos/etcd/clientv3/concurrency/BUILD
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/BUILD
@@ -17,7 +17,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/clientv3:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/etcdserverpb:go_default_library",
         "//vendor/github.com/coreos/etcd/mvcc/mvccpb:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/election.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/election.go
index c092bde0aeb..e18a0ed4ad9 100644
--- a/vendor/github.com/coreos/etcd/clientv3/concurrency/election.go
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/election.go
@@ -15,14 +15,13 @@
 package concurrency
 
 import (
+	"context"
 	"errors"
 	"fmt"
 
 	v3 "github.com/coreos/etcd/clientv3"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/mvcc/mvccpb"
-
-	"golang.org/x/net/context"
 )
 
 var (
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/key.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/key.go
index 9936737756c..4b6e399bd4e 100644
--- a/vendor/github.com/coreos/etcd/clientv3/concurrency/key.go
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/key.go
@@ -15,13 +15,12 @@
 package concurrency
 
 import (
+	"context"
 	"fmt"
 
 	v3 "github.com/coreos/etcd/clientv3"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/mvcc/mvccpb"
-
-	"golang.org/x/net/context"
 )
 
 func waitDelete(ctx context.Context, client *v3.Client, key string, rev int64) error {
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/mutex.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/mutex.go
index 736a9d3d353..dac9ba5a2a3 100644
--- a/vendor/github.com/coreos/etcd/clientv3/concurrency/mutex.go
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/mutex.go
@@ -15,13 +15,12 @@
 package concurrency
 
 import (
+	"context"
 	"fmt"
 	"sync"
 
 	v3 "github.com/coreos/etcd/clientv3"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-
-	"golang.org/x/net/context"
 )
 
 // Mutex implements the sync Locker interface with etcd
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/session.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/session.go
index 55cb553ea4a..c399d64a61d 100644
--- a/vendor/github.com/coreos/etcd/clientv3/concurrency/session.go
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/session.go
@@ -15,11 +15,10 @@
 package concurrency
 
 import (
+	"context"
 	"time"
 
 	v3 "github.com/coreos/etcd/clientv3"
-
-	"golang.org/x/net/context"
 )
 
 const defaultSessionTTL = 60
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/stm.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/stm.go
index 6bfd70ec428..d11023ebe36 100644
--- a/vendor/github.com/coreos/etcd/clientv3/concurrency/stm.go
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/stm.go
@@ -15,11 +15,10 @@
 package concurrency
 
 import (
+	"context"
 	"math"
 
 	v3 "github.com/coreos/etcd/clientv3"
-
-	"golang.org/x/net/context"
 )
 
 // STM is an interface for software transactional memory.
diff --git a/vendor/github.com/coreos/etcd/clientv3/config.go b/vendor/github.com/coreos/etcd/clientv3/config.go
index fee12eaf60b..79d6e2a984f 100644
--- a/vendor/github.com/coreos/etcd/clientv3/config.go
+++ b/vendor/github.com/coreos/etcd/clientv3/config.go
@@ -15,10 +15,10 @@
 package clientv3
 
 import (
+	"context"
 	"crypto/tls"
 	"time"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
@@ -33,12 +33,12 @@ type Config struct {
 	// DialTimeout is the timeout for failing to establish a connection.
 	DialTimeout time.Duration `json:"dial-timeout"`
 
-	// DialKeepAliveTime is the time in seconds after which client pings the server to see if
+	// DialKeepAliveTime is the time after which client pings the server to see if
 	// transport is alive.
 	DialKeepAliveTime time.Duration `json:"dial-keep-alive-time"`
 
-	// DialKeepAliveTimeout is the time in seconds that the client waits for a response for the
-	// keep-alive probe.  If the response is not received in this time, the connection is closed.
+	// DialKeepAliveTimeout is the time that the client waits for a response for the
+	// keep-alive probe. If the response is not received in this time, the connection is closed.
 	DialKeepAliveTimeout time.Duration `json:"dial-keep-alive-timeout"`
 
 	// MaxCallSendMsgSize is the client-side request send limit in bytes.
diff --git a/vendor/github.com/coreos/etcd/clientv3/doc.go b/vendor/github.com/coreos/etcd/clientv3/doc.go
index dacc5bb346f..717fbe435ea 100644
--- a/vendor/github.com/coreos/etcd/clientv3/doc.go
+++ b/vendor/github.com/coreos/etcd/clientv3/doc.go
@@ -16,6 +16,22 @@
 //
 // Create client using `clientv3.New`:
 //
+//	// expect dial time-out on ipv4 blackhole
+//	_, err := clientv3.New(clientv3.Config{
+//		Endpoints:   []string{"http://254.0.0.1:12345"},
+//		DialTimeout: 2 * time.Second
+//	})
+//
+//	// etcd clientv3 >= v3.2.10, grpc/grpc-go >= v1.7.3
+//	if err == context.DeadlineExceeded {
+//		// handle errors
+//	}
+//
+//	// etcd clientv3 <= v3.2.9, grpc/grpc-go <= v1.2.1
+//	if err == grpc.ErrClientConnTimeout {
+//		// handle errors
+//	}
+//
 //	cli, err := clientv3.New(clientv3.Config{
 //		Endpoints:   []string{"localhost:2379", "localhost:22379", "localhost:32379"},
 //		DialTimeout: 5 * time.Second,
@@ -41,10 +57,11 @@
 // The Client has internal state (watchers and leases), so Clients should be reused instead of created as needed.
 // Clients are safe for concurrent use by multiple goroutines.
 //
-// etcd client returns 2 types of errors:
+// etcd client returns 3 types of errors:
 //
-//	1. context error: canceled or deadline exceeded.
-//	2. gRPC error: see https://github.com/coreos/etcd/blob/master/etcdserver/api/v3rpc/rpctypes/error.go
+//  1. context error: canceled or deadline exceeded.
+//  2. gRPC status error: e.g. when clock drifts in server-side before client's context deadline exceeded.
+//  3. gRPC error: see https://github.com/coreos/etcd/blob/master/etcdserver/api/v3rpc/rpctypes/error.go
 //
 // Here is the example code to handle client errors:
 //
@@ -54,6 +71,12 @@
 //			// ctx is canceled by another routine
 //		} else if err == context.DeadlineExceeded {
 //			// ctx is attached with a deadline and it exceeded
+//		} else if ev, ok := status.FromError(err); ok {
+//			code := ev.Code()
+//			if code == codes.DeadlineExceeded {
+//				// server-side context might have timed-out first (due to clock skew)
+//				// while original client-side context is not timed-out yet
+//			}
 //		} else if verr, ok := err.(*v3rpc.ErrEmptyKey); ok {
 //			// process (verr.Errors)
 //		} else {
@@ -61,4 +84,14 @@
 //		}
 //	}
 //
+//	go func() { cli.Close() }()
+//	_, err := kvc.Get(ctx, "a")
+//	if err != nil {
+//		if err == context.Canceled {
+//			// grpc balancer calls 'Get' with an inflight client.Close
+//		} else if err == grpc.ErrClientConnClosing {
+//			// grpc balancer calls 'Get' after client.Close.
+//		}
+//	}
+//
 package clientv3
diff --git a/vendor/github.com/coreos/etcd/clientv3/health_balancer.go b/vendor/github.com/coreos/etcd/clientv3/health_balancer.go
index 52bea90e66e..5918cba8482 100644
--- a/vendor/github.com/coreos/etcd/clientv3/health_balancer.go
+++ b/vendor/github.com/coreos/etcd/clientv3/health_balancer.go
@@ -15,13 +15,13 @@
 package clientv3
 
 import (
+	"context"
 	"errors"
 	"net/url"
 	"strings"
 	"sync"
 	"time"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	healthpb "google.golang.org/grpc/health/grpc_health_v1"
@@ -158,34 +158,26 @@ func (b *healthBalancer) pinned() string {
 
 func (b *healthBalancer) hostPortError(hostPort string, err error) {
 	if b.endpoint(hostPort) == "" {
-		if logger.V(4) {
-			logger.Infof("clientv3/balancer: %q is stale (skip marking as unhealthy on %q)", hostPort, err.Error())
-		}
+		logger.Lvl(4).Infof("clientv3/balancer: %q is stale (skip marking as unhealthy on %q)", hostPort, err.Error())
 		return
 	}
 
 	b.unhealthyMu.Lock()
 	b.unhealthyHostPorts[hostPort] = time.Now()
 	b.unhealthyMu.Unlock()
-	if logger.V(4) {
-		logger.Infof("clientv3/balancer: %q is marked unhealthy (%q)", hostPort, err.Error())
-	}
+	logger.Lvl(4).Infof("clientv3/balancer: %q is marked unhealthy (%q)", hostPort, err.Error())
 }
 
 func (b *healthBalancer) removeUnhealthy(hostPort, msg string) {
 	if b.endpoint(hostPort) == "" {
-		if logger.V(4) {
-			logger.Infof("clientv3/balancer: %q was not in unhealthy (%q)", hostPort, msg)
-		}
+		logger.Lvl(4).Infof("clientv3/balancer: %q was not in unhealthy (%q)", hostPort, msg)
 		return
 	}
 
 	b.unhealthyMu.Lock()
 	delete(b.unhealthyHostPorts, hostPort)
 	b.unhealthyMu.Unlock()
-	if logger.V(4) {
-		logger.Infof("clientv3/balancer: %q is removed from unhealthy (%q)", hostPort, msg)
-	}
+	logger.Lvl(4).Infof("clientv3/balancer: %q is removed from unhealthy (%q)", hostPort, msg)
 }
 
 func (b *healthBalancer) countUnhealthy() (count int) {
@@ -207,9 +199,7 @@ func (b *healthBalancer) cleanupUnhealthy() {
 	for k, v := range b.unhealthyHostPorts {
 		if time.Since(v) > b.healthCheckTimeout {
 			delete(b.unhealthyHostPorts, k)
-			if logger.V(4) {
-				logger.Infof("clientv3/balancer: removed %q from unhealthy after %v", k, b.healthCheckTimeout)
-			}
+			logger.Lvl(4).Infof("clientv3/balancer: removed %q from unhealthy after %v", k, b.healthCheckTimeout)
 		}
 	}
 	b.unhealthyMu.Unlock()
@@ -412,9 +402,7 @@ func (b *healthBalancer) Up(addr grpc.Address) func(error) {
 	}
 
 	if b.pinAddr != "" {
-		if logger.V(4) {
-			logger.Infof("clientv3/balancer: %q is up but not pinned (already pinned %q)", addr.Addr, b.pinAddr)
-		}
+		logger.Lvl(4).Infof("clientv3/balancer: %q is up but not pinned (already pinned %q)", addr.Addr, b.pinAddr)
 		return func(err error) {}
 	}
 
@@ -422,9 +410,7 @@ func (b *healthBalancer) Up(addr grpc.Address) func(error) {
 	close(b.upc)
 	b.downc = make(chan struct{})
 	b.pinAddr = addr.Addr
-	if logger.V(4) {
-		logger.Infof("clientv3/balancer: pin %q", addr.Addr)
-	}
+	logger.Lvl(4).Infof("clientv3/balancer: pin %q", addr.Addr)
 
 	// notify client that a connection is up
 	b.readyOnce.Do(func() { close(b.readyc) })
@@ -441,9 +427,7 @@ func (b *healthBalancer) Up(addr grpc.Address) func(error) {
 		close(b.downc)
 		b.pinAddr = ""
 		b.mu.Unlock()
-		if logger.V(4) {
-			logger.Infof("clientv3/balancer: unpin %q (%q)", addr.Addr, err.Error())
-		}
+		logger.Lvl(4).Infof("clientv3/balancer: unpin %q (%q)", addr.Addr, err.Error())
 	}
 }
 
@@ -470,9 +454,7 @@ func (b *healthBalancer) mayPin(addr grpc.Address) bool {
 	//   3. grpc-healthcheck still SERVING, thus retry to pin
 	// instead, return before grpc-healthcheck if failed within healthcheck timeout
 	if elapsed := time.Since(failedTime); elapsed < b.healthCheckTimeout {
-		if logger.V(4) {
-			logger.Infof("clientv3/balancer: %q is up but not pinned (failed %v ago, require minimum %v after failure)", addr.Addr, elapsed, b.healthCheckTimeout)
-		}
+		logger.Lvl(4).Infof("clientv3/balancer: %q is up but not pinned (failed %v ago, require minimum %v after failure)", addr.Addr, elapsed, b.healthCheckTimeout)
 		return false
 	}
 
diff --git a/vendor/github.com/coreos/etcd/clientv3/kv.go b/vendor/github.com/coreos/etcd/clientv3/kv.go
index 6289605c8e0..5a7469bd4c9 100644
--- a/vendor/github.com/coreos/etcd/clientv3/kv.go
+++ b/vendor/github.com/coreos/etcd/clientv3/kv.go
@@ -15,9 +15,10 @@
 package clientv3
 
 import (
+	"context"
+
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
diff --git a/vendor/github.com/coreos/etcd/clientv3/lease.go b/vendor/github.com/coreos/etcd/clientv3/lease.go
index 15f6ee3bb9a..3729cf37be0 100644
--- a/vendor/github.com/coreos/etcd/clientv3/lease.go
+++ b/vendor/github.com/coreos/etcd/clientv3/lease.go
@@ -15,13 +15,13 @@
 package clientv3
 
 import (
+	"context"
 	"sync"
 	"time"
 
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"
 )
@@ -51,7 +51,7 @@ type LeaseTimeToLiveResponse struct {
 	*pb.ResponseHeader
 	ID LeaseID `json:"id"`
 
-	// TTL is the remaining TTL in seconds for the lease; the lease will expire in under TTL+1 seconds.
+	// TTL is the remaining TTL in seconds for the lease; the lease will expire in under TTL+1 seconds. Expired lease will return -1.
 	TTL int64 `json:"ttl"`
 
 	// GrantedTTL is the initial granted time in seconds upon lease creation/renewal.
@@ -67,6 +67,12 @@ type LeaseStatus struct {
 	// TODO: TTL int64
 }
 
+// LeaseLeasesResponse wraps the protobuf message LeaseLeasesResponse.
+type LeaseLeasesResponse struct {
+	*pb.ResponseHeader
+	Leases []LeaseStatus `json:"leases"`
+}
+
 const (
 	// defaultTTL is the assumed lease TTL used for the first keepalive
 	// deadline before the actual TTL is known to the client.
@@ -108,11 +114,32 @@ type Lease interface {
 	// TimeToLive retrieves the lease information of the given lease ID.
 	TimeToLive(ctx context.Context, id LeaseID, opts ...LeaseOption) (*LeaseTimeToLiveResponse, error)
 
-	// KeepAlive keeps the given lease alive forever.
+	// Leases retrieves all leases.
+	Leases(ctx context.Context) (*LeaseLeasesResponse, error)
+
+	// KeepAlive keeps the given lease alive forever. If the keepalive response
+	// posted to the channel is not consumed immediately, the lease client will
+	// continue sending keep alive requests to the etcd server at least every
+	// second until latest response is consumed.
+	//
+	// The returned "LeaseKeepAliveResponse" channel closes if underlying keep
+	// alive stream is interrupted in some way the client cannot handle itself;
+	// given context "ctx" is canceled or timed out. "LeaseKeepAliveResponse"
+	// from this closed channel is nil.
+	//
+	// If client keep alive loop halts with an unexpected error (e.g. "etcdserver:
+	// no leader") or canceled by the caller (e.g. context.Canceled), the error
+	// is returned. Otherwise, it retries.
+	//
+	// TODO(v4.0): post errors to last keep alive message before closing
+	// (see https://github.com/coreos/etcd/pull/7866)
 	KeepAlive(ctx context.Context, id LeaseID) (<-chan *LeaseKeepAliveResponse, error)
 
-	// KeepAliveOnce renews the lease once. In most of the cases, KeepAlive
-	// should be used instead of KeepAliveOnce.
+	// KeepAliveOnce renews the lease once. The response corresponds to the
+	// first message from calling KeepAlive. If the response has a recoverable
+	// error, KeepAliveOnce will retry the RPC with a new keep alive message.
+	//
+	// In most of the cases, Keepalive should be used instead of KeepAliveOnce.
 	KeepAliveOnce(ctx context.Context, id LeaseID) (*LeaseKeepAliveResponse, error)
 
 	// Close releases all resources Lease keeps for efficient communication
@@ -221,6 +248,18 @@ func (l *lessor) TimeToLive(ctx context.Context, id LeaseID, opts ...LeaseOption
 	return nil, toErr(ctx, err)
 }
 
+func (l *lessor) Leases(ctx context.Context) (*LeaseLeasesResponse, error) {
+	resp, err := l.remote.LeaseLeases(ctx, &pb.LeaseLeasesRequest{}, l.callOpts...)
+	if err == nil {
+		leases := make([]LeaseStatus, len(resp.Leases))
+		for i := range resp.Leases {
+			leases[i] = LeaseStatus{ID: LeaseID(resp.Leases[i].ID)}
+		}
+		return &LeaseLeasesResponse{ResponseHeader: resp.GetHeader(), Leases: leases}, nil
+	}
+	return nil, toErr(ctx, err)
+}
+
 func (l *lessor) KeepAlive(ctx context.Context, id LeaseID) (<-chan *LeaseKeepAliveResponse, error) {
 	ch := make(chan *LeaseKeepAliveResponse, LeaseResponseChSize)
 
diff --git a/vendor/github.com/coreos/etcd/clientv3/logger.go b/vendor/github.com/coreos/etcd/clientv3/logger.go
index 012abdbce63..782e313137a 100644
--- a/vendor/github.com/coreos/etcd/clientv3/logger.go
+++ b/vendor/github.com/coreos/etcd/clientv3/logger.go
@@ -23,10 +23,23 @@ import (
 
 // Logger is the logger used by client library.
 // It implements grpclog.LoggerV2 interface.
-type Logger grpclog.LoggerV2
+type Logger interface {
+	grpclog.LoggerV2
+
+	// Lvl returns logger if logger's verbosity level >= "lvl".
+	// Otherwise, logger that discards all logs.
+	Lvl(lvl int) Logger
+
+	// to satisfy capnslog
+
+	Print(args ...interface{})
+	Printf(format string, args ...interface{})
+	Println(args ...interface{})
+}
 
 var (
-	logger settableLogger
+	loggerMu sync.RWMutex
+	logger   Logger
 )
 
 type settableLogger struct {
@@ -36,38 +49,35 @@ type settableLogger struct {
 
 func init() {
 	// disable client side logs by default
-	logger.mu.Lock()
-	logger.l = grpclog.NewLoggerV2(ioutil.Discard, ioutil.Discard, ioutil.Discard)
-
-	// logger has to override the grpclog at initialization so that
-	// any changes to the grpclog go through logger with locking
-	// instead of through SetLogger
-	//
-	// now updates only happen through settableLogger.set
-	grpclog.SetLoggerV2(&logger)
-	logger.mu.Unlock()
+	logger = &settableLogger{}
+	SetLogger(grpclog.NewLoggerV2(ioutil.Discard, ioutil.Discard, ioutil.Discard))
 }
 
-// SetLogger sets client-side Logger. By default, logs are disabled.
-func SetLogger(l Logger) {
-	logger.set(l)
+// SetLogger sets client-side Logger.
+func SetLogger(l grpclog.LoggerV2) {
+	loggerMu.Lock()
+	logger = NewLogger(l)
+	// override grpclog so that any changes happen with locking
+	grpclog.SetLoggerV2(logger)
+	loggerMu.Unlock()
 }
 
 // GetLogger returns the current logger.
 func GetLogger() Logger {
-	return logger.get()
+	loggerMu.RLock()
+	l := logger
+	loggerMu.RUnlock()
+	return l
 }
 
-func (s *settableLogger) set(l Logger) {
-	s.mu.Lock()
-	logger.l = l
-	grpclog.SetLoggerV2(&logger)
-	s.mu.Unlock()
+// NewLogger returns a new Logger with grpclog.LoggerV2.
+func NewLogger(gl grpclog.LoggerV2) Logger {
+	return &settableLogger{l: gl}
 }
 
-func (s *settableLogger) get() Logger {
+func (s *settableLogger) get() grpclog.LoggerV2 {
 	s.mu.RLock()
-	l := logger.l
+	l := s.l
 	s.mu.RUnlock()
 	return l
 }
@@ -94,3 +104,32 @@ func (s *settableLogger) Print(args ...interface{})                 { s.get().In
 func (s *settableLogger) Printf(format string, args ...interface{}) { s.get().Infof(format, args...) }
 func (s *settableLogger) Println(args ...interface{})               { s.get().Infoln(args...) }
 func (s *settableLogger) V(l int) bool                              { return s.get().V(l) }
+func (s *settableLogger) Lvl(lvl int) Logger {
+	s.mu.RLock()
+	l := s.l
+	s.mu.RUnlock()
+	if l.V(lvl) {
+		return s
+	}
+	return &noLogger{}
+}
+
+type noLogger struct{}
+
+func (*noLogger) Info(args ...interface{})                    {}
+func (*noLogger) Infof(format string, args ...interface{})    {}
+func (*noLogger) Infoln(args ...interface{})                  {}
+func (*noLogger) Warning(args ...interface{})                 {}
+func (*noLogger) Warningf(format string, args ...interface{}) {}
+func (*noLogger) Warningln(args ...interface{})               {}
+func (*noLogger) Error(args ...interface{})                   {}
+func (*noLogger) Errorf(format string, args ...interface{})   {}
+func (*noLogger) Errorln(args ...interface{})                 {}
+func (*noLogger) Fatal(args ...interface{})                   {}
+func (*noLogger) Fatalf(format string, args ...interface{})   {}
+func (*noLogger) Fatalln(args ...interface{})                 {}
+func (*noLogger) Print(args ...interface{})                   {}
+func (*noLogger) Printf(format string, args ...interface{})   {}
+func (*noLogger) Println(args ...interface{})                 {}
+func (*noLogger) V(l int) bool                                { return false }
+func (ng *noLogger) Lvl(lvl int) Logger                       { return ng }
diff --git a/vendor/github.com/coreos/etcd/clientv3/maintenance.go b/vendor/github.com/coreos/etcd/clientv3/maintenance.go
index 67b928fcfb3..f60cfbe4719 100644
--- a/vendor/github.com/coreos/etcd/clientv3/maintenance.go
+++ b/vendor/github.com/coreos/etcd/clientv3/maintenance.go
@@ -15,11 +15,11 @@
 package clientv3
 
 import (
+	"context"
 	"io"
 
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
@@ -28,6 +28,8 @@ type (
 	AlarmResponse      pb.AlarmResponse
 	AlarmMember        pb.AlarmMember
 	StatusResponse     pb.StatusResponse
+	HashKVResponse     pb.HashKVResponse
+	MoveLeaderResponse pb.MoveLeaderResponse
 )
 
 type Maintenance interface {
@@ -49,8 +51,17 @@ type Maintenance interface {
 	// Status gets the status of the endpoint.
 	Status(ctx context.Context, endpoint string) (*StatusResponse, error)
 
+	// HashKV returns a hash of the KV state at the time of the RPC.
+	// If revision is zero, the hash is computed on all keys. If the revision
+	// is non-zero, the hash is computed on all keys at or below the given revision.
+	HashKV(ctx context.Context, endpoint string, rev int64) (*HashKVResponse, error)
+
 	// Snapshot provides a reader for a point-in-time snapshot of etcd.
 	Snapshot(ctx context.Context) (io.ReadCloser, error)
+
+	// MoveLeader requests current leader to transfer its leadership to the transferee.
+	// Request must be made to the leader.
+	MoveLeader(ctx context.Context, transfereeID uint64) (*MoveLeaderResponse, error)
 }
 
 type maintenance struct {
@@ -159,6 +170,19 @@ func (m *maintenance) Status(ctx context.Context, endpoint string) (*StatusRespo
 	return (*StatusResponse)(resp), nil
 }
 
+func (m *maintenance) HashKV(ctx context.Context, endpoint string, rev int64) (*HashKVResponse, error) {
+	remote, cancel, err := m.dial(endpoint)
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	defer cancel()
+	resp, err := remote.HashKV(ctx, &pb.HashKVRequest{Revision: rev}, m.callOpts...)
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	return (*HashKVResponse)(resp), nil
+}
+
 func (m *maintenance) Snapshot(ctx context.Context) (io.ReadCloser, error) {
 	ss, err := m.remote.Snapshot(ctx, &pb.SnapshotRequest{}, m.callOpts...)
 	if err != nil {
@@ -183,5 +207,20 @@ func (m *maintenance) Snapshot(ctx context.Context) (io.ReadCloser, error) {
 		}
 		pw.Close()
 	}()
-	return pr, nil
+	return &snapshotReadCloser{ctx: ctx, ReadCloser: pr}, nil
+}
+
+type snapshotReadCloser struct {
+	ctx context.Context
+	io.ReadCloser
+}
+
+func (rc *snapshotReadCloser) Read(p []byte) (n int, err error) {
+	n, err = rc.ReadCloser.Read(p)
+	return n, toErr(rc.ctx, err)
+}
+
+func (m *maintenance) MoveLeader(ctx context.Context, transfereeID uint64) (*MoveLeaderResponse, error) {
+	resp, err := m.remote.MoveLeader(ctx, &pb.MoveLeaderRequest{TargetID: transfereeID}, m.callOpts...)
+	return (*MoveLeaderResponse)(resp), toErr(ctx, err)
 }
diff --git a/vendor/github.com/coreos/etcd/clientv3/namespace/BUILD b/vendor/github.com/coreos/etcd/clientv3/namespace/BUILD
index 637622753eb..8308c03e74a 100644
--- a/vendor/github.com/coreos/etcd/clientv3/namespace/BUILD
+++ b/vendor/github.com/coreos/etcd/clientv3/namespace/BUILD
@@ -16,7 +16,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/clientv3:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/etcdserverpb:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/clientv3/namespace/kv.go b/vendor/github.com/coreos/etcd/clientv3/namespace/kv.go
index 2b759e0d394..13dd83a2455 100644
--- a/vendor/github.com/coreos/etcd/clientv3/namespace/kv.go
+++ b/vendor/github.com/coreos/etcd/clientv3/namespace/kv.go
@@ -15,11 +15,11 @@
 package namespace
 
 import (
+	"context"
+
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-
-	"golang.org/x/net/context"
 )
 
 type kvPrefix struct {
@@ -74,7 +74,7 @@ func (kv *kvPrefix) Delete(ctx context.Context, key string, opts ...clientv3.OpO
 }
 
 func (kv *kvPrefix) Do(ctx context.Context, op clientv3.Op) (clientv3.OpResponse, error) {
-	if len(op.KeyBytes()) == 0 {
+	if len(op.KeyBytes()) == 0 && !op.IsTxn() {
 		return clientv3.OpResponse{}, rpctypes.ErrEmptyKey
 	}
 	r, err := kv.KV.Do(ctx, kv.prefixOp(op))
@@ -88,6 +88,8 @@ func (kv *kvPrefix) Do(ctx context.Context, op clientv3.Op) (clientv3.OpResponse
 		kv.unprefixPutResponse(r.Put())
 	case r.Del() != nil:
 		kv.unprefixDeleteResponse(r.Del())
+	case r.Txn() != nil:
+		kv.unprefixTxnResponse(r.Txn())
 	}
 	return r, nil
 }
@@ -102,31 +104,17 @@ func (kv *kvPrefix) Txn(ctx context.Context) clientv3.Txn {
 }
 
 func (txn *txnPrefix) If(cs ...clientv3.Cmp) clientv3.Txn {
-	newCmps := make([]clientv3.Cmp, len(cs))
-	for i := range cs {
-		newCmps[i] = cs[i]
-		pfxKey, _ := txn.kv.prefixInterval(cs[i].KeyBytes(), nil)
-		newCmps[i].WithKeyBytes(pfxKey)
-	}
-	txn.Txn = txn.Txn.If(newCmps...)
+	txn.Txn = txn.Txn.If(txn.kv.prefixCmps(cs)...)
 	return txn
 }
 
 func (txn *txnPrefix) Then(ops ...clientv3.Op) clientv3.Txn {
-	newOps := make([]clientv3.Op, len(ops))
-	for i := range ops {
-		newOps[i] = txn.kv.prefixOp(ops[i])
-	}
-	txn.Txn = txn.Txn.Then(newOps...)
+	txn.Txn = txn.Txn.Then(txn.kv.prefixOps(ops)...)
 	return txn
 }
 
 func (txn *txnPrefix) Else(ops ...clientv3.Op) clientv3.Txn {
-	newOps := make([]clientv3.Op, len(ops))
-	for i := range ops {
-		newOps[i] = txn.kv.prefixOp(ops[i])
-	}
-	txn.Txn = txn.Txn.Else(newOps...)
+	txn.Txn = txn.Txn.Else(txn.kv.prefixOps(ops)...)
 	return txn
 }
 
@@ -140,10 +128,14 @@ func (txn *txnPrefix) Commit() (*clientv3.TxnResponse, error) {
 }
 
 func (kv *kvPrefix) prefixOp(op clientv3.Op) clientv3.Op {
-	begin, end := kv.prefixInterval(op.KeyBytes(), op.RangeBytes())
-	op.WithKeyBytes(begin)
-	op.WithRangeBytes(end)
-	return op
+	if !op.IsTxn() {
+		begin, end := kv.prefixInterval(op.KeyBytes(), op.RangeBytes())
+		op.WithKeyBytes(begin)
+		op.WithRangeBytes(end)
+		return op
+	}
+	cmps, thenOps, elseOps := op.Txn()
+	return clientv3.OpTxn(kv.prefixCmps(cmps), kv.prefixOps(thenOps), kv.prefixOps(elseOps))
 }
 
 func (kv *kvPrefix) unprefixGetResponse(resp *clientv3.GetResponse) {
@@ -179,11 +171,36 @@ func (kv *kvPrefix) unprefixTxnResponse(resp *clientv3.TxnResponse) {
 			if tv.ResponseDeleteRange != nil {
 				kv.unprefixDeleteResponse((*clientv3.DeleteResponse)(tv.ResponseDeleteRange))
 			}
+		case *pb.ResponseOp_ResponseTxn:
+			if tv.ResponseTxn != nil {
+				kv.unprefixTxnResponse((*clientv3.TxnResponse)(tv.ResponseTxn))
+			}
 		default:
 		}
 	}
 }
 
-func (p *kvPrefix) prefixInterval(key, end []byte) (pfxKey []byte, pfxEnd []byte) {
-	return prefixInterval(p.pfx, key, end)
+func (kv *kvPrefix) prefixInterval(key, end []byte) (pfxKey []byte, pfxEnd []byte) {
+	return prefixInterval(kv.pfx, key, end)
+}
+
+func (kv *kvPrefix) prefixCmps(cs []clientv3.Cmp) []clientv3.Cmp {
+	newCmps := make([]clientv3.Cmp, len(cs))
+	for i := range cs {
+		newCmps[i] = cs[i]
+		pfxKey, endKey := kv.prefixInterval(cs[i].KeyBytes(), cs[i].RangeEnd)
+		newCmps[i].WithKeyBytes(pfxKey)
+		if len(cs[i].RangeEnd) != 0 {
+			newCmps[i].RangeEnd = endKey
+		}
+	}
+	return newCmps
+}
+
+func (kv *kvPrefix) prefixOps(ops []clientv3.Op) []clientv3.Op {
+	newOps := make([]clientv3.Op, len(ops))
+	for i := range ops {
+		newOps[i] = kv.prefixOp(ops[i])
+	}
+	return newOps
 }
diff --git a/vendor/github.com/coreos/etcd/clientv3/namespace/lease.go b/vendor/github.com/coreos/etcd/clientv3/namespace/lease.go
index c3167fa5d87..f092106cbf2 100644
--- a/vendor/github.com/coreos/etcd/clientv3/namespace/lease.go
+++ b/vendor/github.com/coreos/etcd/clientv3/namespace/lease.go
@@ -16,10 +16,9 @@ package namespace
 
 import (
 	"bytes"
+	"context"
 
 	"github.com/coreos/etcd/clientv3"
-
-	"golang.org/x/net/context"
 )
 
 type leasePrefix struct {
diff --git a/vendor/github.com/coreos/etcd/clientv3/namespace/watch.go b/vendor/github.com/coreos/etcd/clientv3/namespace/watch.go
index 9907211529a..5a9596df5d8 100644
--- a/vendor/github.com/coreos/etcd/clientv3/namespace/watch.go
+++ b/vendor/github.com/coreos/etcd/clientv3/namespace/watch.go
@@ -15,11 +15,10 @@
 package namespace
 
 import (
+	"context"
 	"sync"
 
 	"github.com/coreos/etcd/clientv3"
-
-	"golang.org/x/net/context"
 )
 
 type watcherPrefix struct {
diff --git a/vendor/github.com/coreos/etcd/clientv3/naming/BUILD b/vendor/github.com/coreos/etcd/clientv3/naming/BUILD
index a816fd9dc60..ccc7fdd9791 100644
--- a/vendor/github.com/coreos/etcd/clientv3/naming/BUILD
+++ b/vendor/github.com/coreos/etcd/clientv3/naming/BUILD
@@ -11,7 +11,6 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//vendor/github.com/coreos/etcd/clientv3:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
         "//vendor/google.golang.org/grpc/codes:go_default_library",
         "//vendor/google.golang.org/grpc/naming:go_default_library",
         "//vendor/google.golang.org/grpc/status:go_default_library",
diff --git a/vendor/github.com/coreos/etcd/clientv3/naming/grpc.go b/vendor/github.com/coreos/etcd/clientv3/naming/grpc.go
index 7fabc4f109a..3c0e8e664bd 100644
--- a/vendor/github.com/coreos/etcd/clientv3/naming/grpc.go
+++ b/vendor/github.com/coreos/etcd/clientv3/naming/grpc.go
@@ -15,6 +15,7 @@
 package naming
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 
@@ -23,8 +24,6 @@ import (
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/naming"
 	"google.golang.org/grpc/status"
-
-	"golang.org/x/net/context"
 )
 
 var ErrWatcherClosed = fmt.Errorf("naming: watch closed")
diff --git a/vendor/github.com/coreos/etcd/clientv3/op.go b/vendor/github.com/coreos/etcd/clientv3/op.go
index e18d28662c4..c6ec5bf5200 100644
--- a/vendor/github.com/coreos/etcd/clientv3/op.go
+++ b/vendor/github.com/coreos/etcd/clientv3/op.go
@@ -181,6 +181,8 @@ func (op Op) toRequestOp() *pb.RequestOp {
 	case tDeleteRange:
 		r := &pb.DeleteRangeRequest{Key: op.key, RangeEnd: op.end, PrevKv: op.prevKV}
 		return &pb.RequestOp{Request: &pb.RequestOp_RequestDeleteRange{RequestDeleteRange: r}}
+	case tTxn:
+		return &pb.RequestOp{Request: &pb.RequestOp_RequestTxn{RequestTxn: op.toTxnRequest()}}
 	default:
 		panic("Unknown Op")
 	}
diff --git a/vendor/github.com/coreos/etcd/clientv3/ready_wait.go b/vendor/github.com/coreos/etcd/clientv3/ready_wait.go
index 23eea9367ff..c6ef585b5b4 100644
--- a/vendor/github.com/coreos/etcd/clientv3/ready_wait.go
+++ b/vendor/github.com/coreos/etcd/clientv3/ready_wait.go
@@ -14,7 +14,7 @@
 
 package clientv3
 
-import "golang.org/x/net/context"
+import "context"
 
 // TODO: remove this when "FailFast=false" is fixed.
 // See https://github.com/grpc/grpc-go/issues/1532.
diff --git a/vendor/github.com/coreos/etcd/clientv3/retry.go b/vendor/github.com/coreos/etcd/clientv3/retry.go
index c95b2cad7c4..7f89ba641a4 100644
--- a/vendor/github.com/coreos/etcd/clientv3/retry.go
+++ b/vendor/github.com/coreos/etcd/clientv3/retry.go
@@ -15,19 +15,36 @@
 package clientv3
 
 import (
+	"context"
+
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
+type retryPolicy uint8
+
+const (
+	repeatable retryPolicy = iota
+	nonRepeatable
+)
+
 type rpcFunc func(ctx context.Context) error
-type retryRPCFunc func(context.Context, rpcFunc) error
+type retryRPCFunc func(context.Context, rpcFunc, retryPolicy) error
 type retryStopErrFunc func(error) bool
 
+// immutable requests (e.g. Get) should be retried unless it's
+// an obvious server-side error (e.g. rpctypes.ErrRequestTooLarge).
+//
+// "isRepeatableStopError" returns "true" when an immutable request
+// is interrupted by server-side or gRPC-side error and its status
+// code is not transient (!= codes.Unavailable).
+//
+// Returning "true" means retry should stop, since client cannot
+// handle itself even with retries.
 func isRepeatableStopError(err error) bool {
 	eErr := rpctypes.Error(err)
 	// always stop retry on etcd errors
@@ -39,6 +56,17 @@ func isRepeatableStopError(err error) bool {
 	return ev.Code() != codes.Unavailable
 }
 
+// mutable requests (e.g. Put, Delete, Txn) should only be retried
+// when the status code is codes.Unavailable when initial connection
+// has not been established (no pinned endpoint).
+//
+// "isNonRepeatableStopError" returns "true" when a mutable request
+// is interrupted by non-transient error that client cannot handle itself,
+// or transient error while the connection has already been established
+// (pinned endpoint exists).
+//
+// Returning "true" means retry should stop, otherwise it violates
+// write-at-most-once semantics.
 func isNonRepeatableStopError(err error) bool {
 	ev, _ := status.FromError(err)
 	if ev.Code() != codes.Unavailable {
@@ -48,8 +76,15 @@ func isNonRepeatableStopError(err error) bool {
 	return desc != "there is no address available" && desc != "there is no connection available"
 }
 
-func (c *Client) newRetryWrapper(isStop retryStopErrFunc) retryRPCFunc {
-	return func(rpcCtx context.Context, f rpcFunc) error {
+func (c *Client) newRetryWrapper() retryRPCFunc {
+	return func(rpcCtx context.Context, f rpcFunc, rp retryPolicy) error {
+		var isStop retryStopErrFunc
+		switch rp {
+		case repeatable:
+			isStop = isRepeatableStopError
+		case nonRepeatable:
+			isStop = isNonRepeatableStopError
+		}
 		for {
 			if err := readyWait(rpcCtx, c.ctx, c.balancer.ConnectNotify()); err != nil {
 				return err
@@ -59,17 +94,13 @@ func (c *Client) newRetryWrapper(isStop retryStopErrFunc) retryRPCFunc {
 			if err == nil {
 				return nil
 			}
-			if logger.V(4) {
-				logger.Infof("clientv3/retry: error %q on pinned endpoint %q", err.Error(), pinned)
-			}
+			logger.Lvl(4).Infof("clientv3/retry: error %q on pinned endpoint %q", err.Error(), pinned)
 
 			if s, ok := status.FromError(err); ok && (s.Code() == codes.Unavailable || s.Code() == codes.DeadlineExceeded || s.Code() == codes.Internal) {
 				// mark this before endpoint switch is triggered
 				c.balancer.hostPortError(pinned, err)
 				c.balancer.next()
-				if logger.V(4) {
-					logger.Infof("clientv3/retry: switching from %q due to error %q", pinned, err.Error())
-				}
+				logger.Lvl(4).Infof("clientv3/retry: switching from %q due to error %q", pinned, err.Error())
 			}
 
 			if isStop(err) {
@@ -79,24 +110,20 @@ func (c *Client) newRetryWrapper(isStop retryStopErrFunc) retryRPCFunc {
 	}
 }
 
-func (c *Client) newAuthRetryWrapper() retryRPCFunc {
-	return func(rpcCtx context.Context, f rpcFunc) error {
+func (c *Client) newAuthRetryWrapper(retryf retryRPCFunc) retryRPCFunc {
+	return func(rpcCtx context.Context, f rpcFunc, rp retryPolicy) error {
 		for {
 			pinned := c.balancer.pinned()
-			err := f(rpcCtx)
+			err := retryf(rpcCtx, f, rp)
 			if err == nil {
 				return nil
 			}
-			if logger.V(4) {
-				logger.Infof("clientv3/auth-retry: error %q on pinned endpoint %q", err.Error(), pinned)
-			}
+			logger.Lvl(4).Infof("clientv3/auth-retry: error %q on pinned endpoint %q", err.Error(), pinned)
 			// always stop retry on etcd errors other than invalid auth token
 			if rpctypes.Error(err) == rpctypes.ErrInvalidAuthToken {
 				gterr := c.getToken(rpcCtx)
 				if gterr != nil {
-					if logger.V(4) {
-						logger.Infof("clientv3/auth-retry: cannot retry due to error %q(%q) on pinned endpoint %q", err.Error(), gterr.Error(), pinned)
-					}
+					logger.Lvl(4).Infof("clientv3/auth-retry: cannot retry due to error %q(%q) on pinned endpoint %q", err.Error(), gterr.Error(), pinned)
 					return err // return the original error for simplicity
 				}
 				continue
@@ -106,366 +133,364 @@ func (c *Client) newAuthRetryWrapper() retryRPCFunc {
 	}
 }
 
+type retryKVClient struct {
+	kc     pb.KVClient
+	retryf retryRPCFunc
+}
+
 // RetryKVClient implements a KVClient.
 func RetryKVClient(c *Client) pb.KVClient {
-	repeatableRetry := c.newRetryWrapper(isRepeatableStopError)
-	nonRepeatableRetry := c.newRetryWrapper(isNonRepeatableStopError)
-	conn := pb.NewKVClient(c.conn)
-	retryBasic := &retryKVClient{&nonRepeatableKVClient{conn, nonRepeatableRetry}, repeatableRetry}
-	retryAuthWrapper := c.newAuthRetryWrapper()
 	return &retryKVClient{
-		&nonRepeatableKVClient{retryBasic, retryAuthWrapper},
-		retryAuthWrapper}
+		kc:     pb.NewKVClient(c.conn),
+		retryf: c.newAuthRetryWrapper(c.newRetryWrapper()),
+	}
 }
-
-type retryKVClient struct {
-	*nonRepeatableKVClient
-	repeatableRetry retryRPCFunc
-}
-
 func (rkv *retryKVClient) Range(ctx context.Context, in *pb.RangeRequest, opts ...grpc.CallOption) (resp *pb.RangeResponse, err error) {
-	err = rkv.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rkv.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rkv.kc.Range(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return resp, err
 }
 
-type nonRepeatableKVClient struct {
-	kc                 pb.KVClient
-	nonRepeatableRetry retryRPCFunc
-}
-
-func (rkv *nonRepeatableKVClient) Put(ctx context.Context, in *pb.PutRequest, opts ...grpc.CallOption) (resp *pb.PutResponse, err error) {
-	err = rkv.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rkv *retryKVClient) Put(ctx context.Context, in *pb.PutRequest, opts ...grpc.CallOption) (resp *pb.PutResponse, err error) {
+	err = rkv.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rkv.kc.Put(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rkv *nonRepeatableKVClient) DeleteRange(ctx context.Context, in *pb.DeleteRangeRequest, opts ...grpc.CallOption) (resp *pb.DeleteRangeResponse, err error) {
-	err = rkv.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rkv *retryKVClient) DeleteRange(ctx context.Context, in *pb.DeleteRangeRequest, opts ...grpc.CallOption) (resp *pb.DeleteRangeResponse, err error) {
+	err = rkv.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rkv.kc.DeleteRange(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rkv *nonRepeatableKVClient) Txn(ctx context.Context, in *pb.TxnRequest, opts ...grpc.CallOption) (resp *pb.TxnResponse, err error) {
-	// TODO: repeatableRetry if read-only txn
-	err = rkv.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rkv *retryKVClient) Txn(ctx context.Context, in *pb.TxnRequest, opts ...grpc.CallOption) (resp *pb.TxnResponse, err error) {
+	// TODO: "repeatable" for read-only txn
+	err = rkv.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rkv.kc.Txn(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rkv *nonRepeatableKVClient) Compact(ctx context.Context, in *pb.CompactionRequest, opts ...grpc.CallOption) (resp *pb.CompactionResponse, err error) {
-	err = rkv.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rkv *retryKVClient) Compact(ctx context.Context, in *pb.CompactionRequest, opts ...grpc.CallOption) (resp *pb.CompactionResponse, err error) {
+	err = rkv.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rkv.kc.Compact(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
 type retryLeaseClient struct {
-	lc              pb.LeaseClient
-	repeatableRetry retryRPCFunc
+	lc     pb.LeaseClient
+	retryf retryRPCFunc
 }
 
 // RetryLeaseClient implements a LeaseClient.
 func RetryLeaseClient(c *Client) pb.LeaseClient {
-	retry := &retryLeaseClient{
-		pb.NewLeaseClient(c.conn),
-		c.newRetryWrapper(isRepeatableStopError),
+	return &retryLeaseClient{
+		lc:     pb.NewLeaseClient(c.conn),
+		retryf: c.newAuthRetryWrapper(c.newRetryWrapper()),
 	}
-	return &retryLeaseClient{retry, c.newAuthRetryWrapper()}
 }
 
 func (rlc *retryLeaseClient) LeaseTimeToLive(ctx context.Context, in *pb.LeaseTimeToLiveRequest, opts ...grpc.CallOption) (resp *pb.LeaseTimeToLiveResponse, err error) {
-	err = rlc.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rlc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rlc.lc.LeaseTimeToLive(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
+	return resp, err
+}
+
+func (rlc *retryLeaseClient) LeaseLeases(ctx context.Context, in *pb.LeaseLeasesRequest, opts ...grpc.CallOption) (resp *pb.LeaseLeasesResponse, err error) {
+	err = rlc.retryf(ctx, func(rctx context.Context) error {
+		resp, err = rlc.lc.LeaseLeases(rctx, in, opts...)
+		return err
+	}, repeatable)
 	return resp, err
 }
 
 func (rlc *retryLeaseClient) LeaseGrant(ctx context.Context, in *pb.LeaseGrantRequest, opts ...grpc.CallOption) (resp *pb.LeaseGrantResponse, err error) {
-	err = rlc.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rlc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rlc.lc.LeaseGrant(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return resp, err
 
 }
 
 func (rlc *retryLeaseClient) LeaseRevoke(ctx context.Context, in *pb.LeaseRevokeRequest, opts ...grpc.CallOption) (resp *pb.LeaseRevokeResponse, err error) {
-	err = rlc.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rlc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rlc.lc.LeaseRevoke(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return resp, err
 }
 
 func (rlc *retryLeaseClient) LeaseKeepAlive(ctx context.Context, opts ...grpc.CallOption) (stream pb.Lease_LeaseKeepAliveClient, err error) {
-	err = rlc.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rlc.retryf(ctx, func(rctx context.Context) error {
 		stream, err = rlc.lc.LeaseKeepAlive(rctx, opts...)
 		return err
-	})
+	}, repeatable)
 	return stream, err
 }
 
 type retryClusterClient struct {
-	*nonRepeatableClusterClient
-	repeatableRetry retryRPCFunc
+	cc     pb.ClusterClient
+	retryf retryRPCFunc
 }
 
 // RetryClusterClient implements a ClusterClient.
 func RetryClusterClient(c *Client) pb.ClusterClient {
-	repeatableRetry := c.newRetryWrapper(isRepeatableStopError)
-	nonRepeatableRetry := c.newRetryWrapper(isNonRepeatableStopError)
-	cc := pb.NewClusterClient(c.conn)
-	return &retryClusterClient{&nonRepeatableClusterClient{cc, nonRepeatableRetry}, repeatableRetry}
+	return &retryClusterClient{
+		cc:     pb.NewClusterClient(c.conn),
+		retryf: c.newRetryWrapper(),
+	}
 }
 
 func (rcc *retryClusterClient) MemberList(ctx context.Context, in *pb.MemberListRequest, opts ...grpc.CallOption) (resp *pb.MemberListResponse, err error) {
-	err = rcc.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rcc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rcc.cc.MemberList(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return resp, err
 }
 
-type nonRepeatableClusterClient struct {
-	cc                 pb.ClusterClient
-	nonRepeatableRetry retryRPCFunc
-}
-
-func (rcc *nonRepeatableClusterClient) MemberAdd(ctx context.Context, in *pb.MemberAddRequest, opts ...grpc.CallOption) (resp *pb.MemberAddResponse, err error) {
-	err = rcc.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rcc *retryClusterClient) MemberAdd(ctx context.Context, in *pb.MemberAddRequest, opts ...grpc.CallOption) (resp *pb.MemberAddResponse, err error) {
+	err = rcc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rcc.cc.MemberAdd(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rcc *nonRepeatableClusterClient) MemberRemove(ctx context.Context, in *pb.MemberRemoveRequest, opts ...grpc.CallOption) (resp *pb.MemberRemoveResponse, err error) {
-	err = rcc.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rcc *retryClusterClient) MemberRemove(ctx context.Context, in *pb.MemberRemoveRequest, opts ...grpc.CallOption) (resp *pb.MemberRemoveResponse, err error) {
+	err = rcc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rcc.cc.MemberRemove(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rcc *nonRepeatableClusterClient) MemberUpdate(ctx context.Context, in *pb.MemberUpdateRequest, opts ...grpc.CallOption) (resp *pb.MemberUpdateResponse, err error) {
-	err = rcc.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rcc *retryClusterClient) MemberUpdate(ctx context.Context, in *pb.MemberUpdateRequest, opts ...grpc.CallOption) (resp *pb.MemberUpdateResponse, err error) {
+	err = rcc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rcc.cc.MemberUpdate(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
+type retryMaintenanceClient struct {
+	mc     pb.MaintenanceClient
+	retryf retryRPCFunc
+}
+
 // RetryMaintenanceClient implements a Maintenance.
 func RetryMaintenanceClient(c *Client, conn *grpc.ClientConn) pb.MaintenanceClient {
-	repeatableRetry := c.newRetryWrapper(isRepeatableStopError)
-	nonRepeatableRetry := c.newRetryWrapper(isNonRepeatableStopError)
-	mc := pb.NewMaintenanceClient(conn)
-	return &retryMaintenanceClient{&nonRepeatableMaintenanceClient{mc, nonRepeatableRetry}, repeatableRetry}
-}
-
-type retryMaintenanceClient struct {
-	*nonRepeatableMaintenanceClient
-	repeatableRetry retryRPCFunc
+	return &retryMaintenanceClient{
+		mc:     pb.NewMaintenanceClient(conn),
+		retryf: c.newRetryWrapper(),
+	}
 }
 
 func (rmc *retryMaintenanceClient) Alarm(ctx context.Context, in *pb.AlarmRequest, opts ...grpc.CallOption) (resp *pb.AlarmResponse, err error) {
-	err = rmc.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rmc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rmc.mc.Alarm(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return resp, err
 }
 
 func (rmc *retryMaintenanceClient) Status(ctx context.Context, in *pb.StatusRequest, opts ...grpc.CallOption) (resp *pb.StatusResponse, err error) {
-	err = rmc.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rmc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rmc.mc.Status(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return resp, err
 }
 
 func (rmc *retryMaintenanceClient) Hash(ctx context.Context, in *pb.HashRequest, opts ...grpc.CallOption) (resp *pb.HashResponse, err error) {
-	err = rmc.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rmc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rmc.mc.Hash(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
+	return resp, err
+}
+
+func (rmc *retryMaintenanceClient) HashKV(ctx context.Context, in *pb.HashKVRequest, opts ...grpc.CallOption) (resp *pb.HashKVResponse, err error) {
+	err = rmc.retryf(ctx, func(rctx context.Context) error {
+		resp, err = rmc.mc.HashKV(rctx, in, opts...)
+		return err
+	}, repeatable)
 	return resp, err
 }
 
 func (rmc *retryMaintenanceClient) Snapshot(ctx context.Context, in *pb.SnapshotRequest, opts ...grpc.CallOption) (stream pb.Maintenance_SnapshotClient, err error) {
-	err = rmc.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rmc.retryf(ctx, func(rctx context.Context) error {
 		stream, err = rmc.mc.Snapshot(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return stream, err
 }
 
-type nonRepeatableMaintenanceClient struct {
-	mc                 pb.MaintenanceClient
-	nonRepeatableRetry retryRPCFunc
+func (rmc *retryMaintenanceClient) MoveLeader(ctx context.Context, in *pb.MoveLeaderRequest, opts ...grpc.CallOption) (resp *pb.MoveLeaderResponse, err error) {
+	err = rmc.retryf(ctx, func(rctx context.Context) error {
+		resp, err = rmc.mc.MoveLeader(rctx, in, opts...)
+		return err
+	}, repeatable)
+	return resp, err
 }
 
-func (rmc *nonRepeatableMaintenanceClient) Defragment(ctx context.Context, in *pb.DefragmentRequest, opts ...grpc.CallOption) (resp *pb.DefragmentResponse, err error) {
-	err = rmc.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rmc *retryMaintenanceClient) Defragment(ctx context.Context, in *pb.DefragmentRequest, opts ...grpc.CallOption) (resp *pb.DefragmentResponse, err error) {
+	err = rmc.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rmc.mc.Defragment(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
 type retryAuthClient struct {
-	*nonRepeatableAuthClient
-	repeatableRetry retryRPCFunc
+	ac     pb.AuthClient
+	retryf retryRPCFunc
 }
 
 // RetryAuthClient implements a AuthClient.
 func RetryAuthClient(c *Client) pb.AuthClient {
-	repeatableRetry := c.newRetryWrapper(isRepeatableStopError)
-	nonRepeatableRetry := c.newRetryWrapper(isNonRepeatableStopError)
-	ac := pb.NewAuthClient(c.conn)
-	return &retryAuthClient{&nonRepeatableAuthClient{ac, nonRepeatableRetry}, repeatableRetry}
+	return &retryAuthClient{
+		ac:     pb.NewAuthClient(c.conn),
+		retryf: c.newRetryWrapper(),
+	}
 }
 
 func (rac *retryAuthClient) UserList(ctx context.Context, in *pb.AuthUserListRequest, opts ...grpc.CallOption) (resp *pb.AuthUserListResponse, err error) {
-	err = rac.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.UserList(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return resp, err
 }
 
 func (rac *retryAuthClient) UserGet(ctx context.Context, in *pb.AuthUserGetRequest, opts ...grpc.CallOption) (resp *pb.AuthUserGetResponse, err error) {
-	err = rac.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.UserGet(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return resp, err
 }
 
 func (rac *retryAuthClient) RoleGet(ctx context.Context, in *pb.AuthRoleGetRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleGetResponse, err error) {
-	err = rac.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.RoleGet(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return resp, err
 }
 
 func (rac *retryAuthClient) RoleList(ctx context.Context, in *pb.AuthRoleListRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleListResponse, err error) {
-	err = rac.repeatableRetry(ctx, func(rctx context.Context) error {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.RoleList(rctx, in, opts...)
 		return err
-	})
+	}, repeatable)
 	return resp, err
 }
 
-type nonRepeatableAuthClient struct {
-	ac                 pb.AuthClient
-	nonRepeatableRetry retryRPCFunc
-}
-
-func (rac *nonRepeatableAuthClient) AuthEnable(ctx context.Context, in *pb.AuthEnableRequest, opts ...grpc.CallOption) (resp *pb.AuthEnableResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) AuthEnable(ctx context.Context, in *pb.AuthEnableRequest, opts ...grpc.CallOption) (resp *pb.AuthEnableResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.AuthEnable(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) AuthDisable(ctx context.Context, in *pb.AuthDisableRequest, opts ...grpc.CallOption) (resp *pb.AuthDisableResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) AuthDisable(ctx context.Context, in *pb.AuthDisableRequest, opts ...grpc.CallOption) (resp *pb.AuthDisableResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.AuthDisable(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) UserAdd(ctx context.Context, in *pb.AuthUserAddRequest, opts ...grpc.CallOption) (resp *pb.AuthUserAddResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) UserAdd(ctx context.Context, in *pb.AuthUserAddRequest, opts ...grpc.CallOption) (resp *pb.AuthUserAddResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.UserAdd(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) UserDelete(ctx context.Context, in *pb.AuthUserDeleteRequest, opts ...grpc.CallOption) (resp *pb.AuthUserDeleteResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) UserDelete(ctx context.Context, in *pb.AuthUserDeleteRequest, opts ...grpc.CallOption) (resp *pb.AuthUserDeleteResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.UserDelete(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) UserChangePassword(ctx context.Context, in *pb.AuthUserChangePasswordRequest, opts ...grpc.CallOption) (resp *pb.AuthUserChangePasswordResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) UserChangePassword(ctx context.Context, in *pb.AuthUserChangePasswordRequest, opts ...grpc.CallOption) (resp *pb.AuthUserChangePasswordResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.UserChangePassword(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) UserGrantRole(ctx context.Context, in *pb.AuthUserGrantRoleRequest, opts ...grpc.CallOption) (resp *pb.AuthUserGrantRoleResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) UserGrantRole(ctx context.Context, in *pb.AuthUserGrantRoleRequest, opts ...grpc.CallOption) (resp *pb.AuthUserGrantRoleResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.UserGrantRole(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) UserRevokeRole(ctx context.Context, in *pb.AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (resp *pb.AuthUserRevokeRoleResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) UserRevokeRole(ctx context.Context, in *pb.AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (resp *pb.AuthUserRevokeRoleResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.UserRevokeRole(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) RoleAdd(ctx context.Context, in *pb.AuthRoleAddRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleAddResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) RoleAdd(ctx context.Context, in *pb.AuthRoleAddRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleAddResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.RoleAdd(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) RoleDelete(ctx context.Context, in *pb.AuthRoleDeleteRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleDeleteResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) RoleDelete(ctx context.Context, in *pb.AuthRoleDeleteRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleDeleteResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.RoleDelete(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) RoleGrantPermission(ctx context.Context, in *pb.AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleGrantPermissionResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) RoleGrantPermission(ctx context.Context, in *pb.AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleGrantPermissionResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.RoleGrantPermission(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) RoleRevokePermission(ctx context.Context, in *pb.AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleRevokePermissionResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) RoleRevokePermission(ctx context.Context, in *pb.AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleRevokePermissionResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.RoleRevokePermission(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
 
-func (rac *nonRepeatableAuthClient) Authenticate(ctx context.Context, in *pb.AuthenticateRequest, opts ...grpc.CallOption) (resp *pb.AuthenticateResponse, err error) {
-	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+func (rac *retryAuthClient) Authenticate(ctx context.Context, in *pb.AuthenticateRequest, opts ...grpc.CallOption) (resp *pb.AuthenticateResponse, err error) {
+	err = rac.retryf(ctx, func(rctx context.Context) error {
 		resp, err = rac.ac.Authenticate(rctx, in, opts...)
 		return err
-	})
+	}, nonRepeatable)
 	return resp, err
 }
diff --git a/vendor/github.com/coreos/etcd/clientv3/txn.go b/vendor/github.com/coreos/etcd/clientv3/txn.go
index 1a80c8ebaab..c3c2d248569 100644
--- a/vendor/github.com/coreos/etcd/clientv3/txn.go
+++ b/vendor/github.com/coreos/etcd/clientv3/txn.go
@@ -15,11 +15,11 @@
 package clientv3
 
 import (
+	"context"
 	"sync"
 
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
diff --git a/vendor/github.com/coreos/etcd/clientv3/watch.go b/vendor/github.com/coreos/etcd/clientv3/watch.go
index f39ae0656b2..d7633850e7c 100644
--- a/vendor/github.com/coreos/etcd/clientv3/watch.go
+++ b/vendor/github.com/coreos/etcd/clientv3/watch.go
@@ -15,6 +15,7 @@
 package clientv3
 
 import (
+	"context"
 	"fmt"
 	"sync"
 	"time"
@@ -23,7 +24,6 @@ import (
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	mvccpb "github.com/coreos/etcd/mvcc/mvccpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
@@ -470,7 +470,7 @@ func (w *watchGrpcStream) run() {
 				if ws := w.nextResume(); ws != nil {
 					wc.Send(ws.initReq.toPB())
 				}
-			case pbresp.Canceled:
+			case pbresp.Canceled && pbresp.CompactRevision == 0:
 				delete(cancelSet, pbresp.WatchId)
 				if ws, ok := w.substreams[pbresp.WatchId]; ok {
 					// signal to stream goroutine to update closingc
diff --git a/vendor/github.com/coreos/etcd/compactor/BUILD b/vendor/github.com/coreos/etcd/compactor/BUILD
index ea56f65e6f5..ed619cf771d 100644
--- a/vendor/github.com/coreos/etcd/compactor/BUILD
+++ b/vendor/github.com/coreos/etcd/compactor/BUILD
@@ -5,6 +5,8 @@ go_library(
     srcs = [
         "compactor.go",
         "doc.go",
+        "periodic.go",
+        "revision.go",
     ],
     importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/compactor",
     importpath = "github.com/coreos/etcd/compactor",
@@ -14,7 +16,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/mvcc:go_default_library",
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
         "//vendor/github.com/jonboulle/clockwork:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/compactor/compactor.go b/vendor/github.com/coreos/etcd/compactor/compactor.go
index 5cf7b65094a..8100b69385a 100644
--- a/vendor/github.com/coreos/etcd/compactor/compactor.go
+++ b/vendor/github.com/coreos/etcd/compactor/compactor.go
@@ -15,14 +15,13 @@
 package compactor
 
 import (
-	"sync"
+	"context"
+	"fmt"
 	"time"
 
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	"github.com/coreos/etcd/mvcc"
+
 	"github.com/coreos/pkg/capnslog"
-	"github.com/jonboulle/clockwork"
-	"golang.org/x/net/context"
 )
 
 var (
@@ -30,10 +29,23 @@ var (
 )
 
 const (
-	checkCompactionInterval   = 5 * time.Minute
-	executeCompactionInterval = time.Hour
+	ModePeriodic = "periodic"
+	ModeRevision = "revision"
 )
 
+// Compactor purges old log from the storage periodically.
+type Compactor interface {
+	// Run starts the main loop of the compactor in background.
+	// Use Stop() to halt the loop and release the resource.
+	Run()
+	// Stop halts the main loop of the compactor.
+	Stop()
+	// Pause temporally suspend the compactor not to run compaction. Resume() to unpose.
+	Pause()
+	// Resume restarts the compactor suspended by Pause().
+	Resume()
+}
+
 type Compactable interface {
 	Compact(ctx context.Context, r *pb.CompactionRequest) (*pb.CompactionResponse, error)
 }
@@ -42,96 +54,13 @@ type RevGetter interface {
 	Rev() int64
 }
 
-// Periodic compacts the log by purging revisions older than
-// the configured retention time. Compaction happens hourly.
-type Periodic struct {
-	clock        clockwork.Clock
-	periodInHour int
-
-	rg RevGetter
-	c  Compactable
-
-	revs   []int64
-	ctx    context.Context
-	cancel context.CancelFunc
-
-	mu     sync.Mutex
-	paused bool
-}
-
-func NewPeriodic(h int, rg RevGetter, c Compactable) *Periodic {
-	return &Periodic{
-		clock:        clockwork.NewRealClock(),
-		periodInHour: h,
-		rg:           rg,
-		c:            c,
+func New(mode string, retention time.Duration, rg RevGetter, c Compactable) (Compactor, error) {
+	switch mode {
+	case ModePeriodic:
+		return NewPeriodic(retention, rg, c), nil
+	case ModeRevision:
+		return NewRevision(int64(retention), rg, c), nil
+	default:
+		return nil, fmt.Errorf("unsupported compaction mode %s", mode)
 	}
 }
-
-func (t *Periodic) Run() {
-	t.ctx, t.cancel = context.WithCancel(context.Background())
-	t.revs = make([]int64, 0)
-	clock := t.clock
-
-	go func() {
-		last := clock.Now()
-		for {
-			t.revs = append(t.revs, t.rg.Rev())
-			select {
-			case <-t.ctx.Done():
-				return
-			case <-clock.After(checkCompactionInterval):
-				t.mu.Lock()
-				p := t.paused
-				t.mu.Unlock()
-				if p {
-					continue
-				}
-			}
-
-			if clock.Now().Sub(last) < executeCompactionInterval {
-				continue
-			}
-
-			rev, remaining := t.getRev(t.periodInHour)
-			if rev < 0 {
-				continue
-			}
-
-			plog.Noticef("Starting auto-compaction at revision %d", rev)
-			_, err := t.c.Compact(t.ctx, &pb.CompactionRequest{Revision: rev})
-			if err == nil || err == mvcc.ErrCompacted {
-				t.revs = remaining
-				last = clock.Now()
-				plog.Noticef("Finished auto-compaction at revision %d", rev)
-			} else {
-				plog.Noticef("Failed auto-compaction at revision %d (%v)", rev, err)
-				plog.Noticef("Retry after %v", checkCompactionInterval)
-			}
-		}
-	}()
-}
-
-func (t *Periodic) Stop() {
-	t.cancel()
-}
-
-func (t *Periodic) Pause() {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	t.paused = true
-}
-
-func (t *Periodic) Resume() {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	t.paused = false
-}
-
-func (t *Periodic) getRev(h int) (int64, []int64) {
-	i := len(t.revs) - int(time.Duration(h)*time.Hour/checkCompactionInterval)
-	if i < 0 {
-		return -1, t.revs
-	}
-	return t.revs[i], t.revs[i+1:]
-}
diff --git a/vendor/github.com/coreos/etcd/compactor/periodic.go b/vendor/github.com/coreos/etcd/compactor/periodic.go
new file mode 100644
index 00000000000..9d9164e9c5c
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/compactor/periodic.go
@@ -0,0 +1,191 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package compactor
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/mvcc"
+
+	"github.com/jonboulle/clockwork"
+)
+
+// Periodic compacts the log by purging revisions older than
+// the configured retention time.
+type Periodic struct {
+	clock  clockwork.Clock
+	period time.Duration
+
+	rg RevGetter
+	c  Compactable
+
+	revs   []int64
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	// mu protects paused
+	mu     sync.RWMutex
+	paused bool
+}
+
+// NewPeriodic creates a new instance of Periodic compactor that purges
+// the log older than h Duration.
+func NewPeriodic(h time.Duration, rg RevGetter, c Compactable) *Periodic {
+	return newPeriodic(clockwork.NewRealClock(), h, rg, c)
+}
+
+func newPeriodic(clock clockwork.Clock, h time.Duration, rg RevGetter, c Compactable) *Periodic {
+	t := &Periodic{
+		clock:  clock,
+		period: h,
+		rg:     rg,
+		c:      c,
+		revs:   make([]int64, 0),
+	}
+	t.ctx, t.cancel = context.WithCancel(context.Background())
+	return t
+}
+
+/*
+Compaction period 1-hour:
+  1. compute compaction period, which is 1-hour
+  2. record revisions for every 1/10 of 1-hour (6-minute)
+  3. keep recording revisions with no compaction for first 1-hour
+  4. do compact with revs[0]
+	- success? contiue on for-loop and move sliding window; revs = revs[1:]
+	- failure? update revs, and retry after 1/10 of 1-hour (6-minute)
+
+Compaction period 24-hour:
+  1. compute compaction period, which is 1-hour
+  2. record revisions for every 1/10 of 1-hour (6-minute)
+  3. keep recording revisions with no compaction for first 24-hour
+  4. do compact with revs[0]
+	- success? contiue on for-loop and move sliding window; revs = revs[1:]
+	- failure? update revs, and retry after 1/10 of 1-hour (6-minute)
+
+Compaction period 59-min:
+  1. compute compaction period, which is 59-min
+  2. record revisions for every 1/10 of 59-min (5.9-min)
+  3. keep recording revisions with no compaction for first 59-min
+  4. do compact with revs[0]
+	- success? contiue on for-loop and move sliding window; revs = revs[1:]
+	- failure? update revs, and retry after 1/10 of 59-min (5.9-min)
+
+Compaction period 5-sec:
+  1. compute compaction period, which is 5-sec
+  2. record revisions for every 1/10 of 5-sec (0.5-sec)
+  3. keep recording revisions with no compaction for first 5-sec
+  4. do compact with revs[0]
+	- success? contiue on for-loop and move sliding window; revs = revs[1:]
+	- failure? update revs, and retry after 1/10 of 5-sec (0.5-sec)
+*/
+
+// Run runs periodic compactor.
+func (t *Periodic) Run() {
+	compactInterval := t.getCompactInterval()
+	retryInterval := t.getRetryInterval()
+	retentions := t.getRetentions()
+
+	go func() {
+		lastSuccess := t.clock.Now()
+		baseInterval := t.period
+		for {
+			t.revs = append(t.revs, t.rg.Rev())
+			if len(t.revs) > retentions {
+				t.revs = t.revs[1:] // t.revs[0] is always the rev at t.period ago
+			}
+
+			select {
+			case <-t.ctx.Done():
+				return
+			case <-t.clock.After(retryInterval):
+				t.mu.Lock()
+				p := t.paused
+				t.mu.Unlock()
+				if p {
+					continue
+				}
+			}
+
+			if t.clock.Now().Sub(lastSuccess) < baseInterval {
+				continue
+			}
+
+			// wait up to initial given period
+			if baseInterval == t.period {
+				baseInterval = compactInterval
+			}
+			rev := t.revs[0]
+
+			plog.Noticef("Starting auto-compaction at revision %d (retention: %v)", rev, t.period)
+			_, err := t.c.Compact(t.ctx, &pb.CompactionRequest{Revision: rev})
+			if err == nil || err == mvcc.ErrCompacted {
+				lastSuccess = t.clock.Now()
+				plog.Noticef("Finished auto-compaction at revision %d", rev)
+			} else {
+				plog.Noticef("Failed auto-compaction at revision %d (%v)", rev, err)
+				plog.Noticef("Retry after %v", retryInterval)
+			}
+		}
+	}()
+}
+
+// if given compaction period x is <1-hour, compact every x duration.
+// (e.g. --auto-compaction-mode 'periodic' --auto-compaction-retention='10m', then compact every 10-minute)
+// if given compaction period x is >1-hour, compact every hour.
+// (e.g. --auto-compaction-mode 'periodic' --auto-compaction-retention='2h', then compact every 1-hour)
+func (t *Periodic) getCompactInterval() time.Duration {
+	itv := t.period
+	if itv > time.Hour {
+		itv = time.Hour
+	}
+	return itv
+}
+
+func (t *Periodic) getRetentions() int {
+	return int(t.period/t.getRetryInterval()) + 1
+}
+
+const retryDivisor = 10
+
+func (t *Periodic) getRetryInterval() time.Duration {
+	itv := t.period
+	if itv > time.Hour {
+		itv = time.Hour
+	}
+	return itv / retryDivisor
+}
+
+// Stop stops periodic compactor.
+func (t *Periodic) Stop() {
+	t.cancel()
+}
+
+// Pause pauses periodic compactor.
+func (t *Periodic) Pause() {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.paused = true
+}
+
+// Resume resumes periodic compactor.
+func (t *Periodic) Resume() {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.paused = false
+}
diff --git a/vendor/github.com/coreos/etcd/compactor/revision.go b/vendor/github.com/coreos/etcd/compactor/revision.go
new file mode 100644
index 00000000000..927e41c97fa
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/compactor/revision.go
@@ -0,0 +1,115 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package compactor
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/mvcc"
+
+	"github.com/jonboulle/clockwork"
+)
+
+// Revision compacts the log by purging revisions older than
+// the configured reivison number. Compaction happens every 5 minutes.
+type Revision struct {
+	clock     clockwork.Clock
+	retention int64
+
+	rg RevGetter
+	c  Compactable
+
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	mu     sync.Mutex
+	paused bool
+}
+
+// NewRevision creates a new instance of Revisonal compactor that purges
+// the log older than retention revisions from the current revision.
+func NewRevision(retention int64, rg RevGetter, c Compactable) *Revision {
+	return newRevision(clockwork.NewRealClock(), retention, rg, c)
+}
+
+func newRevision(clock clockwork.Clock, retention int64, rg RevGetter, c Compactable) *Revision {
+	t := &Revision{
+		clock:     clock,
+		retention: retention,
+		rg:        rg,
+		c:         c,
+	}
+	t.ctx, t.cancel = context.WithCancel(context.Background())
+	return t
+}
+
+const revInterval = 5 * time.Minute
+
+// Run runs revision-based compactor.
+func (t *Revision) Run() {
+	prev := int64(0)
+	go func() {
+		for {
+			select {
+			case <-t.ctx.Done():
+				return
+			case <-t.clock.After(revInterval):
+				t.mu.Lock()
+				p := t.paused
+				t.mu.Unlock()
+				if p {
+					continue
+				}
+			}
+
+			rev := t.rg.Rev() - t.retention
+			if rev <= 0 || rev == prev {
+				continue
+			}
+
+			plog.Noticef("Starting auto-compaction at revision %d (retention: %d revisions)", rev, t.retention)
+			_, err := t.c.Compact(t.ctx, &pb.CompactionRequest{Revision: rev})
+			if err == nil || err == mvcc.ErrCompacted {
+				prev = rev
+				plog.Noticef("Finished auto-compaction at revision %d", rev)
+			} else {
+				plog.Noticef("Failed auto-compaction at revision %d (%v)", rev, err)
+				plog.Noticef("Retry after %v", revInterval)
+			}
+		}
+	}()
+}
+
+// Stop stops revision-based compactor.
+func (t *Revision) Stop() {
+	t.cancel()
+}
+
+// Pause pauses revision-based compactor.
+func (t *Revision) Pause() {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.paused = true
+}
+
+// Resume resumes revision-based compactor.
+func (t *Revision) Resume() {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.paused = false
+}
diff --git a/vendor/github.com/coreos/etcd/discovery/BUILD b/vendor/github.com/coreos/etcd/discovery/BUILD
index 69656e67703..11b1096f08c 100644
--- a/vendor/github.com/coreos/etcd/discovery/BUILD
+++ b/vendor/github.com/coreos/etcd/discovery/BUILD
@@ -12,7 +12,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/pkg/types:go_default_library",
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
         "//vendor/github.com/jonboulle/clockwork:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/discovery/discovery.go b/vendor/github.com/coreos/etcd/discovery/discovery.go
index edc842ffb97..7d1fa0d058d 100644
--- a/vendor/github.com/coreos/etcd/discovery/discovery.go
+++ b/vendor/github.com/coreos/etcd/discovery/discovery.go
@@ -17,6 +17,7 @@
 package discovery
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"math"
@@ -31,9 +32,9 @@ import (
 	"github.com/coreos/etcd/client"
 	"github.com/coreos/etcd/pkg/transport"
 	"github.com/coreos/etcd/pkg/types"
+
 	"github.com/coreos/pkg/capnslog"
 	"github.com/jonboulle/clockwork"
-	"golang.org/x/net/context"
 )
 
 var (
diff --git a/vendor/github.com/coreos/etcd/embed/BUILD b/vendor/github.com/coreos/etcd/embed/BUILD
index f94e54b18f2..2f35669710b 100644
--- a/vendor/github.com/coreos/etcd/embed/BUILD
+++ b/vendor/github.com/coreos/etcd/embed/BUILD
@@ -13,10 +13,11 @@ go_library(
     importpath = "github.com/coreos/etcd/embed",
     visibility = ["//visibility:public"],
     deps = [
-        "//vendor/github.com/cockroachdb/cmux:go_default_library",
+        "//vendor/github.com/coreos/etcd/compactor:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v2http:go_default_library",
+        "//vendor/github.com/coreos/etcd/etcdserver/api/v2v3:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3client:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3election:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb:go_default_library",
@@ -38,11 +39,14 @@ go_library(
         "//vendor/github.com/coreos/etcd/wal:go_default_library",
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
         "//vendor/github.com/ghodss/yaml:go_default_library",
+        "//vendor/github.com/grpc-ecosystem/go-grpc-prometheus:go_default_library",
         "//vendor/github.com/grpc-ecosystem/grpc-gateway/runtime:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
+        "//vendor/github.com/soheilhy/cmux:go_default_library",
+        "//vendor/github.com/tmc/grpc-websocket-proxy/wsproxy:go_default_library",
         "//vendor/golang.org/x/net/trace:go_default_library",
         "//vendor/google.golang.org/grpc:go_default_library",
         "//vendor/google.golang.org/grpc/credentials:go_default_library",
+        "//vendor/google.golang.org/grpc/grpclog:go_default_library",
         "//vendor/google.golang.org/grpc/keepalive:go_default_library",
     ],
 )
diff --git a/vendor/github.com/coreos/etcd/embed/config.go b/vendor/github.com/coreos/etcd/embed/config.go
index d414789baae..835e051a7d6 100644
--- a/vendor/github.com/coreos/etcd/embed/config.go
+++ b/vendor/github.com/coreos/etcd/embed/config.go
@@ -15,15 +15,18 @@
 package embed
 
 import (
+	"crypto/tls"
 	"fmt"
 	"io/ioutil"
 	"net"
 	"net/http"
 	"net/url"
+	"os"
 	"path/filepath"
 	"strings"
 	"time"
 
+	"github.com/coreos/etcd/compactor"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/pkg/cors"
 	"github.com/coreos/etcd/pkg/netutil"
@@ -32,8 +35,10 @@ import (
 	"github.com/coreos/etcd/pkg/transport"
 	"github.com/coreos/etcd/pkg/types"
 
+	"github.com/coreos/pkg/capnslog"
 	"github.com/ghodss/yaml"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/grpclog"
 )
 
 const (
@@ -43,6 +48,7 @@ const (
 	DefaultName                  = "default"
 	DefaultMaxSnapshots          = 5
 	DefaultMaxWALs               = 5
+	DefaultMaxTxnOps             = uint(128)
 	DefaultMaxRequestBytes       = 1.5 * 1024 * 1024
 	DefaultGRPCKeepAliveMinTime  = 5 * time.Second
 	DefaultGRPCKeepAliveInterval = 2 * time.Hour
@@ -51,6 +57,16 @@ const (
 	DefaultListenPeerURLs   = "http://localhost:2380"
 	DefaultListenClientURLs = "http://localhost:2379"
 
+	DefaultLogOutput = "default"
+
+	// DefaultStrictReconfigCheck is the default value for "--strict-reconfig-check" flag.
+	// It's enabled by default.
+	DefaultStrictReconfigCheck = true
+	// DefaultEnableV2 is the default value for "--enable-v2" flag.
+	// v2 is enabled by default.
+	// TODO: disable v2 when deprecated.
+	DefaultEnableV2 = true
+
 	// maxElectionMs specifies the maximum value of election timeout.
 	// More details are listed in ../Documentation/tuning.md#time-parameters.
 	maxElectionMs = 50000
@@ -76,15 +92,22 @@ func init() {
 type Config struct {
 	// member
 
-	CorsInfo                *cors.CORSInfo
-	LPUrls, LCUrls          []url.URL
-	Dir                     string `json:"data-dir"`
-	WalDir                  string `json:"wal-dir"`
-	MaxSnapFiles            uint   `json:"max-snapshots"`
-	MaxWalFiles             uint   `json:"max-wals"`
-	Name                    string `json:"name"`
-	SnapCount               uint64 `json:"snapshot-count"`
-	AutoCompactionRetention int    `json:"auto-compaction-retention"`
+	CorsInfo       *cors.CORSInfo
+	LPUrls, LCUrls []url.URL
+	Dir            string `json:"data-dir"`
+	WalDir         string `json:"wal-dir"`
+	MaxSnapFiles   uint   `json:"max-snapshots"`
+	MaxWalFiles    uint   `json:"max-wals"`
+	Name           string `json:"name"`
+	SnapCount      uint64 `json:"snapshot-count"`
+
+	// AutoCompactionMode is either 'periodic' or 'revision'.
+	AutoCompactionMode string `json:"auto-compaction-mode"`
+	// AutoCompactionRetention is either duration string with time unit
+	// (e.g. '5m' for 5-minute), or revision unit (e.g. '5000').
+	// If no time unit is provided and compaction mode is 'periodic',
+	// the unit defaults to hour. For example, '5' translates into 5-hour.
+	AutoCompactionRetention string `json:"auto-compaction-retention"`
 
 	// TickMs is the number of milliseconds between heartbeat ticks.
 	// TODO: decouple tickMs and heartbeat tick (current heartbeat tick = 1).
@@ -122,6 +145,7 @@ type Config struct {
 	InitialElectionTickAdvance bool `json:"initial-election-tick-advance"`
 
 	QuotaBackendBytes int64 `json:"quota-backend-bytes"`
+	MaxTxnOps         uint  `json:"max-txn-ops"`
 	MaxRequestBytes   uint  `json:"max-request-bytes"`
 
 	// gRPC server options
@@ -167,10 +191,13 @@ type Config struct {
 
 	// debug
 
-	Debug        bool   `json:"debug"`
-	LogPkgLevels string `json:"log-package-levels"`
-	EnablePprof  bool   `json:"enable-pprof"`
-	Metrics      string `json:"metrics"`
+	Debug                 bool   `json:"debug"`
+	LogPkgLevels          string `json:"log-package-levels"`
+	LogOutput             string `json:"log-output"`
+	EnablePprof           bool   `json:"enable-pprof"`
+	Metrics               string `json:"metrics"`
+	ListenMetricsUrls     []url.URL
+	ListenMetricsUrlsJSON string `json:"listen-metrics-urls"`
 
 	// ForceNewCluster starts a new cluster even if previously started; unsafe.
 	ForceNewCluster bool `json:"force-new-cluster"`
@@ -192,6 +219,12 @@ type Config struct {
 	// auth
 
 	AuthToken string `json:"auth-token"`
+
+	// Experimental flags
+
+	ExperimentalInitialCorruptCheck bool          `json:"experimental-initial-corrupt-check"`
+	ExperimentalCorruptCheckTime    time.Duration `json:"experimental-corrupt-check-time"`
+	ExperimentalEnableV2V3          string        `json:"experimental-enable-v2v3"`
 }
 
 // configYAML holds the config suitable for yaml parsing
@@ -232,6 +265,7 @@ func NewConfig() *Config {
 		MaxWalFiles:                DefaultMaxWALs,
 		Name:                       DefaultName,
 		SnapCount:                  etcdserver.DefaultSnapCount,
+		MaxTxnOps:                  DefaultMaxTxnOps,
 		MaxRequestBytes:            DefaultMaxRequestBytes,
 		GRPCKeepAliveMinTime:       DefaultGRPCKeepAliveMinTime,
 		GRPCKeepAliveInterval:      DefaultGRPCKeepAliveInterval,
@@ -245,15 +279,69 @@ func NewConfig() *Config {
 		ACUrls:              []url.URL{*acurl},
 		ClusterState:        ClusterStateFlagNew,
 		InitialClusterToken: "etcd-cluster",
-		StrictReconfigCheck: true,
+		StrictReconfigCheck: DefaultStrictReconfigCheck,
+		LogOutput:           DefaultLogOutput,
 		Metrics:             "basic",
-		EnableV2:            true,
+		EnableV2:            DefaultEnableV2,
 		AuthToken:           "simple",
 	}
 	cfg.InitialCluster = cfg.InitialClusterFromName(cfg.Name)
 	return cfg
 }
 
+func logTLSHandshakeFailure(conn *tls.Conn, err error) {
+	state := conn.ConnectionState()
+	remoteAddr := conn.RemoteAddr().String()
+	serverName := state.ServerName
+	if len(state.PeerCertificates) > 0 {
+		cert := state.PeerCertificates[0]
+		ips, dns := cert.IPAddresses, cert.DNSNames
+		plog.Infof("rejected connection from %q (error %q, ServerName %q, IPAddresses %q, DNSNames %q)", remoteAddr, err.Error(), serverName, ips, dns)
+	} else {
+		plog.Infof("rejected connection from %q (error %q, ServerName %q)", remoteAddr, err.Error(), serverName)
+	}
+}
+
+// SetupLogging initializes etcd logging.
+// Must be called after flag parsing.
+func (cfg *Config) SetupLogging() {
+	cfg.ClientTLSInfo.HandshakeFailure = logTLSHandshakeFailure
+	cfg.PeerTLSInfo.HandshakeFailure = logTLSHandshakeFailure
+
+	capnslog.SetGlobalLogLevel(capnslog.INFO)
+	if cfg.Debug {
+		capnslog.SetGlobalLogLevel(capnslog.DEBUG)
+		grpc.EnableTracing = true
+		// enable info, warning, error
+		grpclog.SetLoggerV2(grpclog.NewLoggerV2(os.Stderr, os.Stderr, os.Stderr))
+	} else {
+		// only discard info
+		grpclog.SetLoggerV2(grpclog.NewLoggerV2(ioutil.Discard, os.Stderr, os.Stderr))
+	}
+	if cfg.LogPkgLevels != "" {
+		repoLog := capnslog.MustRepoLogger("github.com/coreos/etcd")
+		settings, err := repoLog.ParseLogLevelConfig(cfg.LogPkgLevels)
+		if err != nil {
+			plog.Warningf("couldn't parse log level string: %s, continuing with default levels", err.Error())
+			return
+		}
+		repoLog.SetLogLevel(settings)
+	}
+
+	// capnslog initially SetFormatter(NewDefaultFormatter(os.Stderr))
+	// where NewDefaultFormatter returns NewJournaldFormatter when syscall.Getppid() == 1
+	// specify 'stdout' or 'stderr' to skip journald logging even when running under systemd
+	switch cfg.LogOutput {
+	case "stdout":
+		capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, cfg.Debug))
+	case "stderr":
+		capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stderr, cfg.Debug))
+	case DefaultLogOutput:
+	default:
+		plog.Panicf(`unknown log-output %q (only supports %q, "stdout", "stderr")`, cfg.LogOutput, DefaultLogOutput)
+	}
+}
+
 func ConfigFromFile(path string) (*Config, error) {
 	cfg := &configYAML{Config: *NewConfig()}
 	if err := cfg.configFromFile(path); err != nil {
@@ -313,6 +401,14 @@ func (cfg *configYAML) configFromFile(path string) error {
 		cfg.ACUrls = []url.URL(u)
 	}
 
+	if cfg.ListenMetricsUrlsJSON != "" {
+		u, err := types.NewURLs(strings.Split(cfg.ListenMetricsUrlsJSON, ","))
+		if err != nil {
+			plog.Fatalf("unexpected error setting up listen-metrics-urls: %v", err)
+		}
+		cfg.ListenMetricsUrls = []url.URL(u)
+	}
+
 	// If a discovery flag is set, clear default initial cluster set by InitialClusterFromName
 	if (cfg.Durl != "" || cfg.DNSCluster != "") && cfg.InitialCluster == defaultInitialCluster {
 		cfg.InitialCluster = ""
@@ -362,6 +458,25 @@ func (cfg *Config) Validate() error {
 	if err := checkBindURLs(cfg.LCUrls); err != nil {
 		return err
 	}
+	if err := checkBindURLs(cfg.ListenMetricsUrls); err != nil {
+		return err
+	}
+	if err := checkHostURLs(cfg.APUrls); err != nil {
+		// TODO: return err in v3.4
+		addrs := make([]string, len(cfg.APUrls))
+		for i := range cfg.APUrls {
+			addrs[i] = cfg.APUrls[i].String()
+		}
+		plog.Warningf("advertise-peer-urls %q is deprecated (%v)", strings.Join(addrs, ","), err)
+	}
+	if err := checkHostURLs(cfg.ACUrls); err != nil {
+		// TODO: return err in v3.4
+		addrs := make([]string, len(cfg.ACUrls))
+		for i := range cfg.ACUrls {
+			addrs[i] = cfg.ACUrls[i].String()
+		}
+		plog.Warningf("advertise-client-urls %q is deprecated (%v)", strings.Join(addrs, ","), err)
+	}
 
 	// Check if conflicting flags are passed.
 	nSet := 0
@@ -379,6 +494,12 @@ func (cfg *Config) Validate() error {
 		return ErrConflictBootstrapFlags
 	}
 
+	if cfg.TickMs <= 0 {
+		return fmt.Errorf("--heartbeat-interval must be >0 (set to %dms)", cfg.TickMs)
+	}
+	if cfg.ElectionMs <= 0 {
+		return fmt.Errorf("--election-timeout must be >0 (set to %dms)", cfg.ElectionMs)
+	}
 	if 5*cfg.TickMs > cfg.ElectionMs {
 		return fmt.Errorf("--election-timeout[%vms] should be at least as 5 times as --heartbeat-interval[%vms]", cfg.ElectionMs, cfg.TickMs)
 	}
@@ -391,6 +512,13 @@ func (cfg *Config) Validate() error {
 		return ErrUnsetAdvertiseClientURLsFlag
 	}
 
+	switch cfg.AutoCompactionMode {
+	case "":
+	case compactor.ModeRevision, compactor.ModePeriodic:
+	default:
+		return fmt.Errorf("unknown auto-compaction-mode %q", cfg.AutoCompactionMode)
+	}
+
 	return nil
 }
 
@@ -536,7 +664,6 @@ func (cfg *Config) UpdateDefaultClusterFromName(defaultInitialCluster string) (s
 }
 
 // checkBindURLs returns an error if any URL uses a domain name.
-// TODO: return error in 3.2.0
 func checkBindURLs(urls []url.URL) error {
 	for _, url := range urls {
 		if url.Scheme == "unix" || url.Scheme == "unixs" {
@@ -557,3 +684,16 @@ func checkBindURLs(urls []url.URL) error {
 	}
 	return nil
 }
+
+func checkHostURLs(urls []url.URL) error {
+	for _, url := range urls {
+		host, _, err := net.SplitHostPort(url.Host)
+		if err != nil {
+			return err
+		}
+		if host == "" {
+			return fmt.Errorf("unexpected empty host (%s)", url.String())
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/coreos/etcd/embed/etcd.go b/vendor/github.com/coreos/etcd/embed/etcd.go
index 9ae55c13467..bd848a7137e 100644
--- a/vendor/github.com/coreos/etcd/embed/etcd.go
+++ b/vendor/github.com/coreos/etcd/embed/etcd.go
@@ -22,12 +22,17 @@ import (
 	defaultLog "log"
 	"net"
 	"net/http"
+	"net/url"
+	"strconv"
 	"sync"
 	"time"
 
+	"github.com/coreos/etcd/compactor"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api/etcdhttp"
 	"github.com/coreos/etcd/etcdserver/api/v2http"
+	"github.com/coreos/etcd/etcdserver/api/v2v3"
+	"github.com/coreos/etcd/etcdserver/api/v3client"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc"
 	"github.com/coreos/etcd/pkg/cors"
 	"github.com/coreos/etcd/pkg/debugutil"
@@ -36,8 +41,9 @@ import (
 	"github.com/coreos/etcd/pkg/types"
 	"github.com/coreos/etcd/rafthttp"
 
-	"github.com/cockroachdb/cmux"
 	"github.com/coreos/pkg/capnslog"
+	grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
+	"github.com/soheilhy/cmux"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/keepalive"
 )
@@ -63,7 +69,8 @@ type Etcd struct {
 	Peers   []*peerListener
 	Clients []net.Listener
 	// a map of contexts for the servers that serves client requests.
-	sctxs map[string]*serveCtx
+	sctxs            map[string]*serveCtx
+	metricsListeners []net.Listener
 
 	Server *etcdserver.EtcdServer
 
@@ -119,14 +126,25 @@ func StartEtcd(inCfg *Config) (e *Etcd, err error) {
 		token   string
 	)
 
+	memberInitialized := true
 	if !isMemberInitialized(cfg) {
+		memberInitialized = false
 		urlsmap, token, err = cfg.PeerURLsMapAndToken("etcd")
 		if err != nil {
 			return e, fmt.Errorf("error setting up initial cluster: %v", err)
 		}
 	}
 
-	srvcfg := &etcdserver.ServerConfig{
+	// AutoCompactionRetention defaults to "0" if not set.
+	if len(cfg.AutoCompactionRetention) == 0 {
+		cfg.AutoCompactionRetention = "0"
+	}
+	autoCompactionRetention, err := parseCompactionRetention(cfg.AutoCompactionMode, cfg.AutoCompactionRetention)
+	if err != nil {
+		return e, err
+	}
+
+	srvcfg := etcdserver.ServerConfig{
 		Name:                       cfg.Name,
 		ClientURLs:                 cfg.ACUrls,
 		PeerURLs:                   cfg.APUrls,
@@ -145,12 +163,16 @@ func StartEtcd(inCfg *Config) (e *Etcd, err error) {
 		TickMs:                     cfg.TickMs,
 		ElectionTicks:              cfg.ElectionTicks(),
 		InitialElectionTickAdvance: cfg.InitialElectionTickAdvance,
-		AutoCompactionRetention:    cfg.AutoCompactionRetention,
+		AutoCompactionRetention:    autoCompactionRetention,
+		AutoCompactionMode:         cfg.AutoCompactionMode,
 		QuotaBackendBytes:          cfg.QuotaBackendBytes,
+		MaxTxnOps:                  cfg.MaxTxnOps,
 		MaxRequestBytes:            cfg.MaxRequestBytes,
 		StrictReconfigCheck:        cfg.StrictReconfigCheck,
 		ClientCertAuthEnabled:      cfg.ClientTLSInfo.ClientCertAuth,
 		AuthToken:                  cfg.AuthToken,
+		InitialCorruptCheck:        cfg.ExperimentalInitialCorruptCheck,
+		CorruptCheckTime:           cfg.ExperimentalCorruptCheckTime,
 		Debug:                      cfg.Debug,
 	}
 
@@ -161,6 +183,16 @@ func StartEtcd(inCfg *Config) (e *Etcd, err error) {
 	// buffer channel so goroutines on closed connections won't wait forever
 	e.errc = make(chan error, len(e.Peers)+len(e.Clients)+2*len(e.sctxs))
 
+	// newly started member ("memberInitialized==false")
+	// does not need corruption check
+	if memberInitialized {
+		if err = e.Server.CheckInitialHashKV(); err != nil {
+			// set "EtcdServer" to nil, so that it does not block on "EtcdServer.Close()"
+			// (nothing to close since rafthttp transports have not been started)
+			e.Server = nil
+			return e, err
+		}
+	}
 	e.Server.Start()
 
 	if err = e.servePeers(); err != nil {
@@ -169,6 +201,9 @@ func StartEtcd(inCfg *Config) (e *Etcd, err error) {
 	if err = e.serveClients(); err != nil {
 		return e, err
 	}
+	if err = e.serveMetrics(); err != nil {
+		return e, err
+	}
 
 	serving = true
 	return e, nil
@@ -208,6 +243,10 @@ func (e *Etcd) Close() {
 		}
 	}
 
+	for i := range e.metricsListeners {
+		e.metricsListeners[i].Close()
+	}
+
 	// close rafthttp transports
 	if e.Server != nil {
 		e.Server.Stop()
@@ -269,7 +308,6 @@ func startPeerListeners(cfg *Config) (peers []*peerListener, err error) {
 	if err = cfg.PeerSelfCert(); err != nil {
 		plog.Fatalf("could not get certs (%v)", err)
 	}
-
 	if !cfg.PeerTLSInfo.Empty() {
 		plog.Infof("peerTLS: %s", cfg.PeerTLSInfo)
 	}
@@ -358,7 +396,6 @@ func startClientListeners(cfg *Config) (sctxs map[string]*serveCtx, err error) {
 	if err = cfg.ClientSelfCert(); err != nil {
 		plog.Fatalf("could not get certs (%v)", err)
 	}
-
 	if cfg.EnablePprof {
 		plog.Infof("pprof is enabled under %s", debugutil.HTTPPrefixPProf)
 	}
@@ -437,12 +474,8 @@ func startClientListeners(cfg *Config) (sctxs map[string]*serveCtx, err error) {
 }
 
 func (e *Etcd) serveClients() (err error) {
-	var ctlscfg *tls.Config
 	if !e.cfg.ClientTLSInfo.Empty() {
 		plog.Infof("ClientTLS: %s", e.cfg.ClientTLSInfo)
-		if ctlscfg, err = e.cfg.ClientTLSInfo.ServerConfig(); err != nil {
-			return err
-		}
 	}
 
 	if e.cfg.CorsInfo.String() != "" {
@@ -452,7 +485,12 @@ func (e *Etcd) serveClients() (err error) {
 	// Start a client server goroutine for each listen address
 	var h http.Handler
 	if e.Config().EnableV2 {
-		h = v2http.NewClientHandler(e.Server, e.Server.Cfg.ReqTimeout())
+		if len(e.Config().ExperimentalEnableV2V3) > 0 {
+			srv := v2v3.NewServer(v3client.New(e.Server), e.cfg.ExperimentalEnableV2V3)
+			h = v2http.NewClientHandler(srv, e.Server.Cfg.ReqTimeout())
+		} else {
+			h = v2http.NewClientHandler(e.Server, e.Server.Cfg.ReqTimeout())
+		}
 	} else {
 		mux := http.NewServeMux()
 		etcdhttp.HandleBasic(mux, e.Server)
@@ -478,12 +516,40 @@ func (e *Etcd) serveClients() (err error) {
 	// start client servers in a goroutine
 	for _, sctx := range e.sctxs {
 		go func(s *serveCtx) {
-			e.errHandler(s.serve(e.Server, ctlscfg, h, e.errHandler, gopts...))
+			e.errHandler(s.serve(e.Server, &e.cfg.ClientTLSInfo, h, e.errHandler, gopts...))
 		}(sctx)
 	}
 	return nil
 }
 
+func (e *Etcd) serveMetrics() (err error) {
+	if e.cfg.Metrics == "extensive" {
+		grpc_prometheus.EnableHandlingTimeHistogram()
+	}
+
+	if len(e.cfg.ListenMetricsUrls) > 0 {
+		metricsMux := http.NewServeMux()
+		etcdhttp.HandleMetricsHealth(metricsMux, e.Server)
+
+		for _, murl := range e.cfg.ListenMetricsUrls {
+			tlsInfo := &e.cfg.ClientTLSInfo
+			if murl.Scheme == "http" {
+				tlsInfo = nil
+			}
+			ml, err := transport.NewListener(murl.Host, murl.Scheme, tlsInfo)
+			if err != nil {
+				return err
+			}
+			e.metricsListeners = append(e.metricsListeners, ml)
+			go func(u url.URL, ln net.Listener) {
+				plog.Info("listening for metrics on ", u.String())
+				e.errHandler(http.Serve(ln, metricsMux))
+			}(murl, ml)
+		}
+	}
+	return nil
+}
+
 func (e *Etcd) errHandler(err error) {
 	select {
 	case <-e.stopc:
@@ -495,3 +561,22 @@ func (e *Etcd) errHandler(err error) {
 	case e.errc <- err:
 	}
 }
+
+func parseCompactionRetention(mode, retention string) (ret time.Duration, err error) {
+	h, err := strconv.Atoi(retention)
+	if err == nil {
+		switch mode {
+		case compactor.ModeRevision:
+			ret = time.Duration(int64(h))
+		case compactor.ModePeriodic:
+			ret = time.Duration(int64(h)) * time.Hour
+		}
+	} else {
+		// periodic compaction
+		ret, err = time.ParseDuration(retention)
+		if err != nil {
+			return 0, fmt.Errorf("error parsing CompactionRetention: %v", err)
+		}
+	}
+	return ret, nil
+}
diff --git a/vendor/github.com/coreos/etcd/embed/serve.go b/vendor/github.com/coreos/etcd/embed/serve.go
index b659bf8b7d6..62b8b57805b 100644
--- a/vendor/github.com/coreos/etcd/embed/serve.go
+++ b/vendor/github.com/coreos/etcd/embed/serve.go
@@ -15,7 +15,7 @@
 package embed
 
 import (
-	"crypto/tls"
+	"context"
 	"io/ioutil"
 	defaultLog "log"
 	"net"
@@ -33,10 +33,11 @@ import (
 	"github.com/coreos/etcd/etcdserver/api/v3rpc"
 	etcdservergw "github.com/coreos/etcd/etcdserver/etcdserverpb/gw"
 	"github.com/coreos/etcd/pkg/debugutil"
+	"github.com/coreos/etcd/pkg/transport"
 
-	"github.com/cockroachdb/cmux"
 	gw "github.com/grpc-ecosystem/grpc-gateway/runtime"
-	"golang.org/x/net/context"
+	"github.com/soheilhy/cmux"
+	"github.com/tmc/grpc-websocket-proxy/wsproxy"
 	"golang.org/x/net/trace"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -64,11 +65,8 @@ type servers struct {
 
 func newServeCtx() *serveCtx {
 	ctx, cancel := context.WithCancel(context.Background())
-	return &serveCtx{
-		ctx:          ctx,
-		cancel:       cancel,
-		userHandlers: make(map[string]http.Handler),
-		serversC:     make(chan *servers, 2), // in case sctx.insecure,sctx.secure true
+	return &serveCtx{ctx: ctx, cancel: cancel, userHandlers: make(map[string]http.Handler),
+		serversC: make(chan *servers, 2), // in case sctx.insecure,sctx.secure true
 	}
 }
 
@@ -77,10 +75,10 @@ func newServeCtx() *serveCtx {
 // read requests and then call handler to reply to them.
 func (sctx *serveCtx) serve(
 	s *etcdserver.EtcdServer,
-	tlscfg *tls.Config,
+	tlsinfo *transport.TLSInfo,
 	handler http.Handler,
 	errHandler func(error),
-	gopts ...grpc.ServerOption) error {
+	gopts ...grpc.ServerOption) (err error) {
 	logger := defaultLog.New(ioutil.Discard, "etcdhttp", 0)
 	<-s.ReadyNotify()
 	plog.Info("ready to serve client requests")
@@ -90,8 +88,15 @@ func (sctx *serveCtx) serve(
 	servElection := v3election.NewElectionServer(v3c)
 	servLock := v3lock.NewLockServer(v3c)
 
+	var gs *grpc.Server
+	defer func() {
+		if err != nil && gs != nil {
+			gs.Stop()
+		}
+	}()
+
 	if sctx.insecure {
-		gs := v3rpc.Server(s, nil, gopts...)
+		gs = v3rpc.Server(s, nil, gopts...)
 		v3electionpb.RegisterElectionServer(gs, servElection)
 		v3lockpb.RegisterLockServer(gs, servLock)
 		if sctx.serviceRegister != nil {
@@ -100,8 +105,8 @@ func (sctx *serveCtx) serve(
 		grpcl := m.Match(cmux.HTTP2())
 		go func() { errHandler(gs.Serve(grpcl)) }()
 
-		opts := []grpc.DialOption{grpc.WithInsecure()}
-		gwmux, err := sctx.registerGateway(opts)
+		var gwmux *gw.ServeMux
+		gwmux, err = sctx.registerGateway([]grpc.DialOption{grpc.WithInsecure()})
 		if err != nil {
 			return err
 		}
@@ -109,7 +114,7 @@ func (sctx *serveCtx) serve(
 		httpmux := sctx.createMux(gwmux, handler)
 
 		srvhttp := &http.Server{
-			Handler:  httpmux,
+			Handler:  wrapMux(httpmux),
 			ErrorLog: logger, // do not log user error
 		}
 		httpl := m.Match(cmux.HTTP1())
@@ -120,7 +125,11 @@ func (sctx *serveCtx) serve(
 	}
 
 	if sctx.secure {
-		gs := v3rpc.Server(s, tlscfg, gopts...)
+		tlscfg, tlsErr := tlsinfo.ServerConfig()
+		if tlsErr != nil {
+			return tlsErr
+		}
+		gs = v3rpc.Server(s, tlscfg, gopts...)
 		v3electionpb.RegisterElectionServer(gs, servElection)
 		v3lockpb.RegisterLockServer(gs, servLock)
 		if sctx.serviceRegister != nil {
@@ -133,17 +142,22 @@ func (sctx *serveCtx) serve(
 		dtls.InsecureSkipVerify = true
 		creds := credentials.NewTLS(dtls)
 		opts := []grpc.DialOption{grpc.WithTransportCredentials(creds)}
-		gwmux, err := sctx.registerGateway(opts)
+		var gwmux *gw.ServeMux
+		gwmux, err = sctx.registerGateway(opts)
 		if err != nil {
 			return err
 		}
 
-		tlsl := tls.NewListener(m.Match(cmux.Any()), tlscfg)
+		var tlsl net.Listener
+		tlsl, err = transport.NewTLSListener(m.Match(cmux.Any()), tlsinfo)
+		if err != nil {
+			return err
+		}
 		// TODO: add debug flag; enable logging when debug flag is set
 		httpmux := sctx.createMux(gwmux, handler)
 
 		srv := &http.Server{
-			Handler:   httpmux,
+			Handler:   wrapMux(httpmux),
 			TLSConfig: tlscfg,
 			ErrorLog:  logger, // do not log user error
 		}
@@ -158,7 +172,7 @@ func (sctx *serveCtx) serve(
 }
 
 // grpcHandlerFunc returns an http.Handler that delegates to grpcServer on incoming gRPC
-// connections or otherHandler otherwise. Copied from cockroachdb.
+// connections or otherHandler otherwise. Given in gRPC docs.
 func grpcHandlerFunc(grpcServer *grpc.Server, otherHandler http.Handler) http.Handler {
 	if otherHandler == nil {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -215,13 +229,40 @@ func (sctx *serveCtx) createMux(gwmux *gw.ServeMux, handler http.Handler) *http.
 		httpmux.Handle(path, h)
 	}
 
-	httpmux.Handle("/v3alpha/", gwmux)
+	httpmux.Handle(
+		"/v3beta/",
+		wsproxy.WebsocketProxy(
+			gwmux,
+			wsproxy.WithRequestMutator(
+				// Default to the POST method for streams
+				func(incoming *http.Request, outgoing *http.Request) *http.Request {
+					outgoing.Method = "POST"
+					return outgoing
+				},
+			),
+		),
+	)
 	if handler != nil {
 		httpmux.Handle("/", handler)
 	}
 	return httpmux
 }
 
+// wraps HTTP multiplexer to mute requests to /v3alpha
+// TODO: deprecate this in 3.4 release
+func wrapMux(mux *http.ServeMux) http.Handler { return &v3alphaMutator{mux: mux} }
+
+type v3alphaMutator struct {
+	mux *http.ServeMux
+}
+
+func (m *v3alphaMutator) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	if req != nil && req.URL != nil && strings.HasPrefix(req.URL.Path, "/v3alpha/") {
+		req.URL.Path = strings.Replace(req.URL.Path, "/v3alpha/", "/v3beta/", 1)
+	}
+	m.mux.ServeHTTP(rw, req)
+}
+
 func (sctx *serveCtx) registerUserHandler(s string, h http.Handler) {
 	if sctx.userHandlers[s] != nil {
 		plog.Warningf("path %s already registered by user handler", s)
diff --git a/vendor/github.com/coreos/etcd/etcdserver/BUILD b/vendor/github.com/coreos/etcd/etcdserver/BUILD
index 6d96026b0e7..679cb7bdd41 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/BUILD
@@ -10,6 +10,7 @@ go_library(
         "cluster_util.go",
         "config.go",
         "consistent_index.go",
+        "corrupt.go",
         "doc.go",
         "errors.go",
         "metrics.go",
@@ -28,10 +29,12 @@ go_library(
     deps = [
         "//vendor/github.com/coreos/etcd/alarm:go_default_library",
         "//vendor/github.com/coreos/etcd/auth:go_default_library",
+        "//vendor/github.com/coreos/etcd/clientv3:go_default_library",
         "//vendor/github.com/coreos/etcd/compactor:go_default_library",
         "//vendor/github.com/coreos/etcd/discovery:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v2http/httptypes:go_default_library",
+        "//vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/etcdserverpb:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/membership:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/stats:go_default_library",
@@ -63,7 +66,6 @@ go_library(
         "//vendor/github.com/gogo/protobuf/proto:go_default_library",
         "//vendor/github.com/golang/protobuf/proto:go_default_library",
         "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/BUILD
index c7a6b3bde29..2827f5782ea 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/BUILD
@@ -32,6 +32,7 @@ filegroup(
         ":package-srcs",
         "//vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp:all-srcs",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v2http:all-srcs",
+        "//vendor/github.com/coreos/etcd/etcdserver/api/v2v3:all-srcs",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3client:all-srcs",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3election:all-srcs",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3lock:all-srcs",
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/capability.go b/vendor/github.com/coreos/etcd/etcdserver/api/capability.go
index 5e2de58e9a1..eb34383d7f9 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/capability.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/capability.go
@@ -37,6 +37,7 @@ var (
 		"3.0.0": {AuthCapability: true, V3rpcCapability: true},
 		"3.1.0": {AuthCapability: true, V3rpcCapability: true},
 		"3.2.0": {AuthCapability: true, V3rpcCapability: true},
+		"3.3.0": {AuthCapability: true, V3rpcCapability: true},
 	}
 
 	enableMapMu sync.RWMutex
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/cluster.go b/vendor/github.com/coreos/etcd/etcdserver/api/cluster.go
index 87face4a139..654c25804ce 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/cluster.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/cluster.go
@@ -33,9 +33,6 @@ type Cluster interface {
 	// Member retrieves a particular member based on ID, or nil if the
 	// member does not exist in the cluster
 	Member(id types.ID) *membership.Member
-	// IsIDRemoved checks whether the given ID has been removed from this
-	// cluster at some point in the past
-	IsIDRemoved(id types.ID) bool
 	// Version is the cluster-wide minimum major.minor version.
 	Version() *semver.Version
 }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/BUILD
index 88827eaaf4b..e0c1fedbb4f 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/BUILD
@@ -4,6 +4,8 @@ go_library(
     name = "go_default_library",
     srcs = [
         "base.go",
+        "doc.go",
+        "metrics.go",
         "peer.go",
     ],
     importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp",
@@ -21,8 +23,7 @@ go_library(
         "//vendor/github.com/coreos/etcd/rafthttp:go_default_library",
         "//vendor/github.com/coreos/etcd/version:go_default_library",
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
-        "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
+        "//vendor/github.com/prometheus/client_golang/prometheus/promhttp:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/base.go b/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/base.go
index 283b32dbf95..f0d3b0bd3d2 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/base.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/base.go
@@ -20,19 +20,14 @@ import (
 	"fmt"
 	"net/http"
 	"strings"
-	"time"
 
 	etcdErr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api"
 	"github.com/coreos/etcd/etcdserver/api/v2http/httptypes"
-	"github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/pkg/logutil"
-	"github.com/coreos/etcd/raft"
 	"github.com/coreos/etcd/version"
 	"github.com/coreos/pkg/capnslog"
-	"github.com/prometheus/client_golang/prometheus"
-	"golang.org/x/net/context"
 )
 
 var (
@@ -42,42 +37,19 @@ var (
 
 const (
 	configPath  = "/config"
-	metricsPath = "/metrics"
-	healthPath  = "/health"
 	varsPath    = "/debug/vars"
 	versionPath = "/version"
 )
 
 // HandleBasic adds handlers to a mux for serving JSON etcd client requests
 // that do not access the v2 store.
-func HandleBasic(mux *http.ServeMux, server *etcdserver.EtcdServer) {
+func HandleBasic(mux *http.ServeMux, server etcdserver.ServerPeer) {
 	mux.HandleFunc(varsPath, serveVars)
 	mux.HandleFunc(configPath+"/local/log", logHandleFunc)
-	mux.Handle(metricsPath, prometheus.Handler())
-	mux.Handle(healthPath, healthHandler(server))
+	HandleMetricsHealth(mux, server)
 	mux.HandleFunc(versionPath, versionHandler(server.Cluster(), serveVersion))
 }
 
-func healthHandler(server *etcdserver.EtcdServer) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if !allowMethod(w, r, "GET") {
-			return
-		}
-		if uint64(server.Leader()) == raft.None {
-			http.Error(w, `{"health": "false"}`, http.StatusServiceUnavailable)
-			return
-		}
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-		defer cancel()
-		if _, err := server.Do(ctx, etcdserverpb.Request{Method: "QGET"}); err != nil {
-			http.Error(w, `{"health": "false"}`, http.StatusServiceUnavailable)
-			return
-		}
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte(`{"health": "true"}`))
-	}
-}
-
 func versionHandler(c api.Cluster, fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		v := c.Version()
diff --git a/vendor/github.com/coreos/etcd/pkg/monotime/monotime.go b/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/doc.go
similarity index 70%
rename from vendor/github.com/coreos/etcd/pkg/monotime/monotime.go
rename to vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/doc.go
index a5e16ce1d0e..a03b626204f 100644
--- a/vendor/github.com/coreos/etcd/pkg/monotime/monotime.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/doc.go
@@ -1,4 +1,4 @@
-// Copyright 2016 The etcd Authors
+// Copyright 2017 The etcd Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,15 +12,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package monotime
-
-import (
-	"time"
-)
-
-// Time represents a point in monotonic time
-type Time uint64
-
-func (t Time) Add(d time.Duration) Time {
-	return Time(uint64(t) + uint64(d.Nanoseconds()))
-}
+// Package etcdhttp implements HTTP transportation layer for etcdserver.
+package etcdhttp
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/metrics.go b/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/metrics.go
new file mode 100644
index 00000000000..f374adcaa6b
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/metrics.go
@@ -0,0 +1,101 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package etcdhttp
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"github.com/coreos/etcd/etcdserver"
+	"github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/raft"
+
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+const (
+	pathMetrics = "/metrics"
+	PathHealth  = "/health"
+)
+
+// HandleMetricsHealth registers metrics and health handlers.
+func HandleMetricsHealth(mux *http.ServeMux, srv etcdserver.ServerV2) {
+	mux.Handle(pathMetrics, promhttp.Handler())
+	mux.Handle(PathHealth, NewHealthHandler(func() Health { return checkHealth(srv) }))
+}
+
+// HandlePrometheus registers prometheus handler on '/metrics'.
+func HandlePrometheus(mux *http.ServeMux) {
+	mux.Handle(pathMetrics, promhttp.Handler())
+}
+
+// HandleHealth registers health handler on '/health'.
+func HandleHealth(mux *http.ServeMux, srv etcdserver.ServerV2) {
+	mux.Handle(PathHealth, NewHealthHandler(func() Health { return checkHealth(srv) }))
+}
+
+// NewHealthHandler handles '/health' requests.
+func NewHealthHandler(hfunc func() Health) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			w.Header().Set("Allow", http.MethodGet)
+			http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
+			return
+		}
+		h := hfunc()
+		d, _ := json.Marshal(h)
+		if h.Health != "true" {
+			http.Error(w, string(d), http.StatusServiceUnavailable)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		w.Write(d)
+	}
+}
+
+// Health defines etcd server health status.
+// TODO: remove manual parsing in etcdctl cluster-health
+type Health struct {
+	Health string `json:"health"`
+}
+
+// TODO: server NOSPACE, etcdserver.ErrNoLeader in health API
+
+func checkHealth(srv etcdserver.ServerV2) Health {
+	h := Health{Health: "true"}
+
+	as := srv.Alarms()
+	if len(as) > 0 {
+		h.Health = "false"
+	}
+
+	if h.Health == "true" {
+		if uint64(srv.Leader()) == raft.None {
+			h.Health = "false"
+		}
+	}
+
+	if h.Health == "true" {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		_, err := srv.Do(ctx, etcdserverpb.Request{Method: "QGET"})
+		cancel()
+		if err != nil {
+			h.Health = "false"
+		}
+	}
+	return h
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/peer.go b/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/peer.go
index 721bae3c600..0a9213b01a9 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/peer.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp/peer.go
@@ -29,13 +29,8 @@ const (
 )
 
 // NewPeerHandler generates an http.Handler to handle etcd peer requests.
-func NewPeerHandler(s *etcdserver.EtcdServer) http.Handler {
-	var lh http.Handler
-	l := s.Lessor()
-	if l != nil {
-		lh = leasehttp.NewHandler(l, func() <-chan struct{} { return s.ApplyWait() })
-	}
-	return newPeerHandler(s.Cluster(), s.RaftHandler(), lh)
+func NewPeerHandler(s etcdserver.ServerPeer) http.Handler {
+	return newPeerHandler(s.Cluster(), s.RaftHandler(), s.LeaseHandler())
 }
 
 func newPeerHandler(cluster api.Cluster, raftHandler http.Handler, leaseHandler http.Handler) http.Handler {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v2http/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/v2http/BUILD
index d592bab6a28..8e048fc7c60 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v2http/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v2http/BUILD
@@ -29,7 +29,6 @@ go_library(
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
         "//vendor/github.com/jonboulle/clockwork:go_default_library",
         "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v2http/client.go b/vendor/github.com/coreos/etcd/etcdserver/api/v2http/client.go
index aa1e71ec329..6aaf3db360b 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v2http/client.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v2http/client.go
@@ -15,6 +15,7 @@
 package v2http
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -37,8 +38,8 @@ import (
 	"github.com/coreos/etcd/etcdserver/stats"
 	"github.com/coreos/etcd/pkg/types"
 	"github.com/coreos/etcd/store"
+
 	"github.com/jonboulle/clockwork"
-	"golang.org/x/net/context"
 )
 
 const (
@@ -50,22 +51,21 @@ const (
 )
 
 // NewClientHandler generates a muxed http.Handler with the given parameters to serve etcd client requests.
-func NewClientHandler(server *etcdserver.EtcdServer, timeout time.Duration) http.Handler {
+func NewClientHandler(server etcdserver.ServerPeer, timeout time.Duration) http.Handler {
 	mux := http.NewServeMux()
 	etcdhttp.HandleBasic(mux, server)
 	handleV2(mux, server, timeout)
 	return requestLogger(mux)
 }
 
-func handleV2(mux *http.ServeMux, server *etcdserver.EtcdServer, timeout time.Duration) {
+func handleV2(mux *http.ServeMux, server etcdserver.ServerV2, timeout time.Duration) {
 	sec := auth.NewStore(server, timeout)
 	kh := &keysHandler{
 		sec:                   sec,
 		server:                server,
 		cluster:               server.Cluster(),
-		timer:                 server,
 		timeout:               timeout,
-		clientCertAuthEnabled: server.Cfg.ClientCertAuthEnabled,
+		clientCertAuthEnabled: server.ClientCertAuthEnabled(),
 	}
 
 	sh := &statsHandler{
@@ -78,7 +78,7 @@ func handleV2(mux *http.ServeMux, server *etcdserver.EtcdServer, timeout time.Du
 		cluster: server.Cluster(),
 		timeout: timeout,
 		clock:   clockwork.NewRealClock(),
-		clientCertAuthEnabled: server.Cfg.ClientCertAuthEnabled,
+		clientCertAuthEnabled: server.ClientCertAuthEnabled(),
 	}
 
 	mah := &machinesHandler{cluster: server.Cluster()}
@@ -86,7 +86,7 @@ func handleV2(mux *http.ServeMux, server *etcdserver.EtcdServer, timeout time.Du
 	sech := &authHandler{
 		sec:                   sec,
 		cluster:               server.Cluster(),
-		clientCertAuthEnabled: server.Cfg.ClientCertAuthEnabled,
+		clientCertAuthEnabled: server.ClientCertAuthEnabled(),
 	}
 	mux.HandleFunc("/", http.NotFound)
 	mux.Handle(keysPrefix, kh)
@@ -102,9 +102,8 @@ func handleV2(mux *http.ServeMux, server *etcdserver.EtcdServer, timeout time.Du
 
 type keysHandler struct {
 	sec                   auth.Store
-	server                etcdserver.Server
+	server                etcdserver.ServerV2
 	cluster               api.Cluster
-	timer                 etcdserver.RaftTimer
 	timeout               time.Duration
 	clientCertAuthEnabled bool
 }
@@ -142,7 +141,7 @@ func (h *keysHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 	switch {
 	case resp.Event != nil:
-		if err := writeKeyEvent(w, resp.Event, noValueOnSuccess, h.timer); err != nil {
+		if err := writeKeyEvent(w, resp, noValueOnSuccess); err != nil {
 			// Should never be reached
 			plog.Errorf("error writing event (%v)", err)
 		}
@@ -150,7 +149,7 @@ func (h *keysHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	case resp.Watcher != nil:
 		ctx, cancel := context.WithTimeout(context.Background(), defaultWatchTimeout)
 		defer cancel()
-		handleKeyWatch(ctx, w, resp.Watcher, rr.Stream, h.timer)
+		handleKeyWatch(ctx, w, resp, rr.Stream)
 	default:
 		writeKeyError(w, errors.New("received response with no Event/Watcher!"))
 	}
@@ -170,7 +169,7 @@ func (h *machinesHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 type membersHandler struct {
 	sec                   auth.Store
-	server                etcdserver.Server
+	server                etcdserver.ServerV2
 	cluster               api.Cluster
 	timeout               time.Duration
 	clock                 clockwork.Clock
@@ -318,7 +317,7 @@ func (h *statsHandler) serveLeader(w http.ResponseWriter, r *http.Request) {
 // a server Request, performing validation of supplied fields as appropriate.
 // If any validation fails, an empty Request and non-nil error is returned.
 func parseKeyRequest(r *http.Request, clock clockwork.Clock) (etcdserverpb.Request, bool, error) {
-	noValueOnSuccess := false
+	var noValueOnSuccess bool
 	emptyReq := etcdserverpb.Request{}
 
 	err := r.ParseForm()
@@ -503,14 +502,15 @@ func parseKeyRequest(r *http.Request, clock clockwork.Clock) (etcdserverpb.Reque
 // writeKeyEvent trims the prefix of key path in a single Event under
 // StoreKeysPrefix, serializes it and writes the resulting JSON to the given
 // ResponseWriter, along with the appropriate headers.
-func writeKeyEvent(w http.ResponseWriter, ev *store.Event, noValueOnSuccess bool, rt etcdserver.RaftTimer) error {
+func writeKeyEvent(w http.ResponseWriter, resp etcdserver.Response, noValueOnSuccess bool) error {
+	ev := resp.Event
 	if ev == nil {
 		return errors.New("cannot write empty Event!")
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("X-Etcd-Index", fmt.Sprint(ev.EtcdIndex))
-	w.Header().Set("X-Raft-Index", fmt.Sprint(rt.Index()))
-	w.Header().Set("X-Raft-Term", fmt.Sprint(rt.Term()))
+	w.Header().Set("X-Raft-Index", fmt.Sprint(resp.Index))
+	w.Header().Set("X-Raft-Term", fmt.Sprint(resp.Term))
 
 	if ev.IsCreated() {
 		w.WriteHeader(http.StatusCreated)
@@ -552,7 +552,8 @@ func writeKeyError(w http.ResponseWriter, err error) {
 	}
 }
 
-func handleKeyWatch(ctx context.Context, w http.ResponseWriter, wa store.Watcher, stream bool, rt etcdserver.RaftTimer) {
+func handleKeyWatch(ctx context.Context, w http.ResponseWriter, resp etcdserver.Response, stream bool) {
+	wa := resp.Watcher
 	defer wa.Remove()
 	ech := wa.EventChan()
 	var nch <-chan bool
@@ -562,8 +563,8 @@ func handleKeyWatch(ctx context.Context, w http.ResponseWriter, wa store.Watcher
 
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("X-Etcd-Index", fmt.Sprint(wa.StartIndex()))
-	w.Header().Set("X-Raft-Index", fmt.Sprint(rt.Index()))
-	w.Header().Set("X-Raft-Term", fmt.Sprint(rt.Term()))
+	w.Header().Set("X-Raft-Index", fmt.Sprint(resp.Index))
+	w.Header().Set("X-Raft-Term", fmt.Sprint(resp.Term))
 	w.WriteHeader(http.StatusOK)
 
 	// Ensure headers are flushed early, in case of long polling
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/BUILD
new file mode 100644
index 00000000000..deab960fdfe
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/BUILD
@@ -0,0 +1,42 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cluster.go",
+        "doc.go",
+        "server.go",
+        "store.go",
+        "watcher.go",
+    ],
+    importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/etcdserver/api/v2v3",
+    importpath = "github.com/coreos/etcd/etcdserver/api/v2v3",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/coreos/etcd/clientv3:go_default_library",
+        "//vendor/github.com/coreos/etcd/clientv3/concurrency:go_default_library",
+        "//vendor/github.com/coreos/etcd/error:go_default_library",
+        "//vendor/github.com/coreos/etcd/etcdserver:go_default_library",
+        "//vendor/github.com/coreos/etcd/etcdserver/api:go_default_library",
+        "//vendor/github.com/coreos/etcd/etcdserver/etcdserverpb:go_default_library",
+        "//vendor/github.com/coreos/etcd/etcdserver/membership:go_default_library",
+        "//vendor/github.com/coreos/etcd/mvcc/mvccpb:go_default_library",
+        "//vendor/github.com/coreos/etcd/pkg/types:go_default_library",
+        "//vendor/github.com/coreos/etcd/store:go_default_library",
+        "//vendor/github.com/coreos/go-semver/semver:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/cluster.go b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/cluster.go
new file mode 100644
index 00000000000..b53e6d7c8b5
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/cluster.go
@@ -0,0 +1,31 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v2v3
+
+import (
+	"github.com/coreos/etcd/etcdserver/membership"
+	"github.com/coreos/etcd/pkg/types"
+
+	"github.com/coreos/go-semver/semver"
+)
+
+func (s *v2v3Server) ID() types.ID {
+	// TODO: use an actual member ID
+	return types.ID(0xe7cd2f00d)
+}
+func (s *v2v3Server) ClientURLs() []string                  { panic("STUB") }
+func (s *v2v3Server) Members() []*membership.Member         { panic("STUB") }
+func (s *v2v3Server) Member(id types.ID) *membership.Member { panic("STUB") }
+func (s *v2v3Server) Version() *semver.Version              { panic("STUB") }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/doc.go b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/doc.go
new file mode 100644
index 00000000000..2ff372f1876
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/doc.go
@@ -0,0 +1,16 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package v2v3 provides a ServerV2 implementation backed by clientv3.Client.
+package v2v3
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/server.go b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/server.go
new file mode 100644
index 00000000000..2ef63ce6844
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/server.go
@@ -0,0 +1,117 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v2v3
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/coreos/etcd/clientv3"
+	"github.com/coreos/etcd/etcdserver"
+	"github.com/coreos/etcd/etcdserver/api"
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/etcdserver/membership"
+	"github.com/coreos/etcd/pkg/types"
+
+	"github.com/coreos/go-semver/semver"
+)
+
+type fakeStats struct{}
+
+func (s *fakeStats) SelfStats() []byte   { return nil }
+func (s *fakeStats) LeaderStats() []byte { return nil }
+func (s *fakeStats) StoreStats() []byte  { return nil }
+
+type v2v3Server struct {
+	c     *clientv3.Client
+	store *v2v3Store
+	fakeStats
+}
+
+func NewServer(c *clientv3.Client, pfx string) etcdserver.ServerPeer {
+	return &v2v3Server{c: c, store: newStore(c, pfx)}
+}
+
+func (s *v2v3Server) ClientCertAuthEnabled() bool { return false }
+
+func (s *v2v3Server) LeaseHandler() http.Handler { panic("STUB: lease handler") }
+func (s *v2v3Server) RaftHandler() http.Handler  { panic("STUB: raft handler") }
+
+func (s *v2v3Server) Leader() types.ID {
+	ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
+	defer cancel()
+	resp, err := s.c.Status(ctx, s.c.Endpoints()[0])
+	if err != nil {
+		return 0
+	}
+	return types.ID(resp.Leader)
+}
+
+func (s *v2v3Server) AddMember(ctx context.Context, memb membership.Member) ([]*membership.Member, error) {
+	resp, err := s.c.MemberAdd(ctx, memb.PeerURLs)
+	if err != nil {
+		return nil, err
+	}
+	return v3MembersToMembership(resp.Members), nil
+}
+
+func (s *v2v3Server) RemoveMember(ctx context.Context, id uint64) ([]*membership.Member, error) {
+	resp, err := s.c.MemberRemove(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	return v3MembersToMembership(resp.Members), nil
+}
+
+func (s *v2v3Server) UpdateMember(ctx context.Context, m membership.Member) ([]*membership.Member, error) {
+	resp, err := s.c.MemberUpdate(ctx, uint64(m.ID), m.PeerURLs)
+	if err != nil {
+		return nil, err
+	}
+	return v3MembersToMembership(resp.Members), nil
+}
+
+func v3MembersToMembership(v3membs []*pb.Member) []*membership.Member {
+	membs := make([]*membership.Member, len(v3membs))
+	for i, m := range v3membs {
+		membs[i] = &membership.Member{
+			ID: types.ID(m.ID),
+			RaftAttributes: membership.RaftAttributes{
+				PeerURLs: m.PeerURLs,
+			},
+			Attributes: membership.Attributes{
+				Name:       m.Name,
+				ClientURLs: m.ClientURLs,
+			},
+		}
+	}
+	return membs
+}
+
+func (s *v2v3Server) ClusterVersion() *semver.Version { return s.Version() }
+func (s *v2v3Server) Cluster() api.Cluster            { return s }
+func (s *v2v3Server) Alarms() []*pb.AlarmMember       { return nil }
+
+func (s *v2v3Server) Do(ctx context.Context, r pb.Request) (etcdserver.Response, error) {
+	applier := etcdserver.NewApplierV2(s.store, nil)
+	reqHandler := etcdserver.NewStoreRequestV2Handler(s.store, applier)
+	req := (*etcdserver.RequestV2)(&r)
+	resp, err := req.Handle(ctx, reqHandler)
+	if resp.Err != nil {
+		return resp, resp.Err
+	}
+	return resp, err
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/store.go b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/store.go
new file mode 100644
index 00000000000..444f93f3a8e
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/store.go
@@ -0,0 +1,620 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v2v3
+
+import (
+	"context"
+	"fmt"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/coreos/etcd/clientv3"
+	"github.com/coreos/etcd/clientv3/concurrency"
+	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/mvcc/mvccpb"
+	"github.com/coreos/etcd/store"
+)
+
+// store implements the Store interface for V2 using
+// a v3 client.
+type v2v3Store struct {
+	c *clientv3.Client
+	// pfx is the v3 prefix where keys should be stored.
+	pfx string
+	ctx context.Context
+}
+
+const maxPathDepth = 63
+
+var errUnsupported = fmt.Errorf("TTLs are unsupported")
+
+func NewStore(c *clientv3.Client, pfx string) store.Store { return newStore(c, pfx) }
+
+func newStore(c *clientv3.Client, pfx string) *v2v3Store { return &v2v3Store{c, pfx, c.Ctx()} }
+
+func (s *v2v3Store) Index() uint64 { panic("STUB") }
+
+func (s *v2v3Store) Get(nodePath string, recursive, sorted bool) (*store.Event, error) {
+	key := s.mkPath(nodePath)
+	resp, err := s.c.Txn(s.ctx).Then(
+		clientv3.OpGet(key+"/"),
+		clientv3.OpGet(key),
+	).Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	if kvs := resp.Responses[0].GetResponseRange().Kvs; len(kvs) != 0 || isRoot(nodePath) {
+		nodes, err := s.getDir(nodePath, recursive, sorted, resp.Header.Revision)
+		if err != nil {
+			return nil, err
+		}
+		cidx, midx := uint64(0), uint64(0)
+		if len(kvs) > 0 {
+			cidx, midx = mkV2Rev(kvs[0].CreateRevision), mkV2Rev(kvs[0].ModRevision)
+		}
+		return &store.Event{
+			Action: store.Get,
+			Node: &store.NodeExtern{
+				Key:           nodePath,
+				Dir:           true,
+				Nodes:         nodes,
+				CreatedIndex:  cidx,
+				ModifiedIndex: midx,
+			},
+			EtcdIndex: mkV2Rev(resp.Header.Revision),
+		}, nil
+	}
+
+	kvs := resp.Responses[1].GetResponseRange().Kvs
+	if len(kvs) == 0 {
+		return nil, etcdErr.NewError(etcdErr.EcodeKeyNotFound, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+
+	return &store.Event{
+		Action:    store.Get,
+		Node:      s.mkV2Node(kvs[0]),
+		EtcdIndex: mkV2Rev(resp.Header.Revision),
+	}, nil
+}
+
+func (s *v2v3Store) getDir(nodePath string, recursive, sorted bool, rev int64) ([]*store.NodeExtern, error) {
+	rootNodes, err := s.getDirDepth(nodePath, 1, rev)
+	if err != nil || !recursive {
+		return rootNodes, err
+	}
+	nextNodes := rootNodes
+	nodes := make(map[string]*store.NodeExtern)
+	// Breadth walk the subdirectories
+	for i := 2; len(nextNodes) > 0; i++ {
+		for _, n := range nextNodes {
+			nodes[n.Key] = n
+			if parent := nodes[path.Dir(n.Key)]; parent != nil {
+				parent.Nodes = append(parent.Nodes, n)
+			}
+		}
+		if nextNodes, err = s.getDirDepth(nodePath, i, rev); err != nil {
+			return nil, err
+		}
+	}
+	return rootNodes, nil
+}
+
+func (s *v2v3Store) getDirDepth(nodePath string, depth int, rev int64) ([]*store.NodeExtern, error) {
+	pd := s.mkPathDepth(nodePath, depth)
+	resp, err := s.c.Get(s.ctx, pd, clientv3.WithPrefix(), clientv3.WithRev(rev))
+	if err != nil {
+		return nil, err
+	}
+
+	nodes := make([]*store.NodeExtern, len(resp.Kvs))
+	for i, kv := range resp.Kvs {
+		nodes[i] = s.mkV2Node(kv)
+	}
+	return nodes, nil
+}
+
+func (s *v2v3Store) Set(
+	nodePath string,
+	dir bool,
+	value string,
+	expireOpts store.TTLOptionSet,
+) (*store.Event, error) {
+	if expireOpts.Refresh || !expireOpts.ExpireTime.IsZero() {
+		return nil, errUnsupported
+	}
+
+	if isRoot(nodePath) {
+		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+	}
+
+	ecode := 0
+	applyf := func(stm concurrency.STM) error {
+		parent := path.Dir(nodePath)
+		if !isRoot(parent) && stm.Rev(s.mkPath(parent)+"/") == 0 {
+			ecode = etcdErr.EcodeKeyNotFound
+			return nil
+		}
+
+		key := s.mkPath(nodePath)
+		if dir {
+			if stm.Rev(key) != 0 {
+				// exists as non-dir
+				ecode = etcdErr.EcodeNotDir
+				return nil
+			}
+			key = key + "/"
+		} else if stm.Rev(key+"/") != 0 {
+			ecode = etcdErr.EcodeNotFile
+			return nil
+		}
+		stm.Put(key, value, clientv3.WithPrevKV())
+		stm.Put(s.mkActionKey(), store.Set)
+		return nil
+	}
+
+	resp, err := s.newSTM(applyf)
+	if err != nil {
+		return nil, err
+	}
+	if ecode != 0 {
+		return nil, etcdErr.NewError(ecode, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+
+	createRev := resp.Header.Revision
+	var pn *store.NodeExtern
+	if pkv := prevKeyFromPuts(resp); pkv != nil {
+		pn = s.mkV2Node(pkv)
+		createRev = pkv.CreateRevision
+	}
+
+	vp := &value
+	if dir {
+		vp = nil
+	}
+	return &store.Event{
+		Action: store.Set,
+		Node: &store.NodeExtern{
+			Key:           nodePath,
+			Value:         vp,
+			Dir:           dir,
+			ModifiedIndex: mkV2Rev(resp.Header.Revision),
+			CreatedIndex:  mkV2Rev(createRev),
+		},
+		PrevNode:  pn,
+		EtcdIndex: mkV2Rev(resp.Header.Revision),
+	}, nil
+}
+
+func (s *v2v3Store) Update(nodePath, newValue string, expireOpts store.TTLOptionSet) (*store.Event, error) {
+	if isRoot(nodePath) {
+		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+	}
+
+	if expireOpts.Refresh || !expireOpts.ExpireTime.IsZero() {
+		return nil, errUnsupported
+	}
+
+	key := s.mkPath(nodePath)
+	ecode := 0
+	applyf := func(stm concurrency.STM) error {
+		if rev := stm.Rev(key + "/"); rev != 0 {
+			ecode = etcdErr.EcodeNotFile
+			return nil
+		}
+		if rev := stm.Rev(key); rev == 0 {
+			ecode = etcdErr.EcodeKeyNotFound
+			return nil
+		}
+		stm.Put(key, newValue, clientv3.WithPrevKV())
+		stm.Put(s.mkActionKey(), store.Update)
+		return nil
+	}
+
+	resp, err := s.newSTM(applyf)
+	if err != nil {
+		return nil, err
+	}
+	if ecode != 0 {
+		return nil, etcdErr.NewError(etcdErr.EcodeNotFile, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+
+	pkv := prevKeyFromPuts(resp)
+	return &store.Event{
+		Action: store.Update,
+		Node: &store.NodeExtern{
+			Key:           nodePath,
+			Value:         &newValue,
+			ModifiedIndex: mkV2Rev(resp.Header.Revision),
+			CreatedIndex:  mkV2Rev(pkv.CreateRevision),
+		},
+		PrevNode:  s.mkV2Node(pkv),
+		EtcdIndex: mkV2Rev(resp.Header.Revision),
+	}, nil
+}
+
+func (s *v2v3Store) Create(
+	nodePath string,
+	dir bool,
+	value string,
+	unique bool,
+	expireOpts store.TTLOptionSet,
+) (*store.Event, error) {
+	if isRoot(nodePath) {
+		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+	}
+	if expireOpts.Refresh || !expireOpts.ExpireTime.IsZero() {
+		return nil, errUnsupported
+	}
+	ecode := 0
+	applyf := func(stm concurrency.STM) error {
+		ecode = 0
+		key := s.mkPath(nodePath)
+		if unique {
+			// append unique item under the node path
+			for {
+				key = nodePath + "/" + fmt.Sprintf("%020s", time.Now())
+				key = path.Clean(path.Join("/", key))
+				key = s.mkPath(key)
+				if stm.Rev(key) == 0 {
+					break
+				}
+			}
+		}
+		if stm.Rev(key) > 0 || stm.Rev(key+"/") > 0 {
+			ecode = etcdErr.EcodeNodeExist
+			return nil
+		}
+		// build path if any directories in path do not exist
+		dirs := []string{}
+		for p := path.Dir(nodePath); !isRoot(p); p = path.Dir(p) {
+			pp := s.mkPath(p)
+			if stm.Rev(pp) > 0 {
+				ecode = etcdErr.EcodeNotDir
+				return nil
+			}
+			if stm.Rev(pp+"/") == 0 {
+				dirs = append(dirs, pp+"/")
+			}
+		}
+		for _, d := range dirs {
+			stm.Put(d, "")
+		}
+
+		if dir {
+			// directories marked with extra slash in key name
+			key += "/"
+		}
+		stm.Put(key, value)
+		stm.Put(s.mkActionKey(), store.Create)
+		return nil
+	}
+
+	resp, err := s.newSTM(applyf)
+	if err != nil {
+		return nil, err
+	}
+	if ecode != 0 {
+		return nil, etcdErr.NewError(ecode, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+
+	var v *string
+	if !dir {
+		v = &value
+	}
+
+	return &store.Event{
+		Action: store.Create,
+		Node: &store.NodeExtern{
+			Key:           nodePath,
+			Value:         v,
+			Dir:           dir,
+			ModifiedIndex: mkV2Rev(resp.Header.Revision),
+			CreatedIndex:  mkV2Rev(resp.Header.Revision),
+		},
+		EtcdIndex: mkV2Rev(resp.Header.Revision),
+	}, nil
+}
+
+func (s *v2v3Store) CompareAndSwap(
+	nodePath string,
+	prevValue string,
+	prevIndex uint64,
+	value string,
+	expireOpts store.TTLOptionSet,
+) (*store.Event, error) {
+	if isRoot(nodePath) {
+		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+	}
+	if expireOpts.Refresh || !expireOpts.ExpireTime.IsZero() {
+		return nil, errUnsupported
+	}
+
+	key := s.mkPath(nodePath)
+	resp, err := s.c.Txn(s.ctx).If(
+		s.mkCompare(nodePath, prevValue, prevIndex)...,
+	).Then(
+		clientv3.OpPut(key, value, clientv3.WithPrevKV()),
+		clientv3.OpPut(s.mkActionKey(), store.CompareAndSwap),
+	).Else(
+		clientv3.OpGet(key),
+		clientv3.OpGet(key+"/"),
+	).Commit()
+
+	if err != nil {
+		return nil, err
+	}
+	if !resp.Succeeded {
+		return nil, compareFail(nodePath, prevValue, prevIndex, resp)
+	}
+
+	pkv := resp.Responses[0].GetResponsePut().PrevKv
+	return &store.Event{
+		Action: store.CompareAndSwap,
+		Node: &store.NodeExtern{
+			Key:           nodePath,
+			Value:         &value,
+			CreatedIndex:  mkV2Rev(pkv.CreateRevision),
+			ModifiedIndex: mkV2Rev(resp.Header.Revision),
+		},
+		PrevNode:  s.mkV2Node(pkv),
+		EtcdIndex: mkV2Rev(resp.Header.Revision),
+	}, nil
+}
+
+func (s *v2v3Store) Delete(nodePath string, dir, recursive bool) (*store.Event, error) {
+	if isRoot(nodePath) {
+		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+	}
+	if !dir && !recursive {
+		return s.deleteNode(nodePath)
+	}
+	if !recursive {
+		return s.deleteEmptyDir(nodePath)
+	}
+
+	dels := make([]clientv3.Op, maxPathDepth+1)
+	dels[0] = clientv3.OpDelete(s.mkPath(nodePath)+"/", clientv3.WithPrevKV())
+	for i := 1; i < maxPathDepth; i++ {
+		dels[i] = clientv3.OpDelete(s.mkPathDepth(nodePath, i), clientv3.WithPrefix())
+	}
+	dels[maxPathDepth] = clientv3.OpPut(s.mkActionKey(), store.Delete)
+
+	resp, err := s.c.Txn(s.ctx).If(
+		clientv3.Compare(clientv3.Version(s.mkPath(nodePath)+"/"), ">", 0),
+		clientv3.Compare(clientv3.Version(s.mkPathDepth(nodePath, maxPathDepth)+"/"), "=", 0),
+	).Then(
+		dels...,
+	).Commit()
+	if err != nil {
+		return nil, err
+	}
+	if !resp.Succeeded {
+		return nil, etcdErr.NewError(etcdErr.EcodeNodeExist, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+	dresp := resp.Responses[0].GetResponseDeleteRange()
+	return &store.Event{
+		Action:    store.Delete,
+		PrevNode:  s.mkV2Node(dresp.PrevKvs[0]),
+		EtcdIndex: mkV2Rev(resp.Header.Revision),
+	}, nil
+}
+
+func (s *v2v3Store) deleteEmptyDir(nodePath string) (*store.Event, error) {
+	resp, err := s.c.Txn(s.ctx).If(
+		clientv3.Compare(clientv3.Version(s.mkPathDepth(nodePath, 1)), "=", 0).WithPrefix(),
+	).Then(
+		clientv3.OpDelete(s.mkPath(nodePath)+"/", clientv3.WithPrevKV()),
+		clientv3.OpPut(s.mkActionKey(), store.Delete),
+	).Commit()
+	if err != nil {
+		return nil, err
+	}
+	if !resp.Succeeded {
+		return nil, etcdErr.NewError(etcdErr.EcodeDirNotEmpty, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+	dresp := resp.Responses[0].GetResponseDeleteRange()
+	if len(dresp.PrevKvs) == 0 {
+		return nil, etcdErr.NewError(etcdErr.EcodeNodeExist, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+	return &store.Event{
+		Action:    store.Delete,
+		PrevNode:  s.mkV2Node(dresp.PrevKvs[0]),
+		EtcdIndex: mkV2Rev(resp.Header.Revision),
+	}, nil
+}
+
+func (s *v2v3Store) deleteNode(nodePath string) (*store.Event, error) {
+	resp, err := s.c.Txn(s.ctx).If(
+		clientv3.Compare(clientv3.Version(s.mkPath(nodePath)+"/"), "=", 0),
+	).Then(
+		clientv3.OpDelete(s.mkPath(nodePath), clientv3.WithPrevKV()),
+		clientv3.OpPut(s.mkActionKey(), store.Delete),
+	).Commit()
+	if err != nil {
+		return nil, err
+	}
+	if !resp.Succeeded {
+		return nil, etcdErr.NewError(etcdErr.EcodeNotFile, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+	pkvs := resp.Responses[0].GetResponseDeleteRange().PrevKvs
+	if len(pkvs) == 0 {
+		return nil, etcdErr.NewError(etcdErr.EcodeKeyNotFound, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+	pkv := pkvs[0]
+	return &store.Event{
+		Action: store.Delete,
+		Node: &store.NodeExtern{
+			Key:           nodePath,
+			CreatedIndex:  mkV2Rev(pkv.CreateRevision),
+			ModifiedIndex: mkV2Rev(resp.Header.Revision),
+		},
+		PrevNode:  s.mkV2Node(pkv),
+		EtcdIndex: mkV2Rev(resp.Header.Revision),
+	}, nil
+}
+
+func (s *v2v3Store) CompareAndDelete(nodePath, prevValue string, prevIndex uint64) (*store.Event, error) {
+	if isRoot(nodePath) {
+		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+	}
+
+	key := s.mkPath(nodePath)
+	resp, err := s.c.Txn(s.ctx).If(
+		s.mkCompare(nodePath, prevValue, prevIndex)...,
+	).Then(
+		clientv3.OpDelete(key, clientv3.WithPrevKV()),
+		clientv3.OpPut(s.mkActionKey(), store.CompareAndDelete),
+	).Else(
+		clientv3.OpGet(key),
+		clientv3.OpGet(key+"/"),
+	).Commit()
+
+	if err != nil {
+		return nil, err
+	}
+	if !resp.Succeeded {
+		return nil, compareFail(nodePath, prevValue, prevIndex, resp)
+	}
+
+	// len(pkvs) > 1 since txn only succeeds when key exists
+	pkv := resp.Responses[0].GetResponseDeleteRange().PrevKvs[0]
+	return &store.Event{
+		Action: store.CompareAndDelete,
+		Node: &store.NodeExtern{
+			Key:           nodePath,
+			CreatedIndex:  mkV2Rev(pkv.CreateRevision),
+			ModifiedIndex: mkV2Rev(resp.Header.Revision),
+		},
+		PrevNode:  s.mkV2Node(pkv),
+		EtcdIndex: mkV2Rev(resp.Header.Revision),
+	}, nil
+}
+
+func compareFail(nodePath, prevValue string, prevIndex uint64, resp *clientv3.TxnResponse) error {
+	if dkvs := resp.Responses[1].GetResponseRange().Kvs; len(dkvs) > 0 {
+		return etcdErr.NewError(etcdErr.EcodeNotFile, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+	kvs := resp.Responses[0].GetResponseRange().Kvs
+	if len(kvs) == 0 {
+		return etcdErr.NewError(etcdErr.EcodeKeyNotFound, nodePath, mkV2Rev(resp.Header.Revision))
+	}
+	kv := kvs[0]
+	indexMatch := (prevIndex == 0 || kv.ModRevision == int64(prevIndex))
+	valueMatch := (prevValue == "" || string(kv.Value) == prevValue)
+	var cause string
+	switch {
+	case indexMatch && !valueMatch:
+		cause = fmt.Sprintf("[%v != %v]", prevValue, string(kv.Value))
+	case valueMatch && !indexMatch:
+		cause = fmt.Sprintf("[%v != %v]", prevIndex, kv.ModRevision)
+	default:
+		cause = fmt.Sprintf("[%v != %v] [%v != %v]", prevValue, string(kv.Value), prevIndex, kv.ModRevision)
+	}
+	return etcdErr.NewError(etcdErr.EcodeTestFailed, cause, mkV2Rev(resp.Header.Revision))
+}
+
+func (s *v2v3Store) mkCompare(nodePath, prevValue string, prevIndex uint64) []clientv3.Cmp {
+	key := s.mkPath(nodePath)
+	cmps := []clientv3.Cmp{clientv3.Compare(clientv3.Version(key), ">", 0)}
+	if prevIndex != 0 {
+		cmps = append(cmps, clientv3.Compare(clientv3.ModRevision(key), "=", mkV3Rev(prevIndex)))
+	}
+	if prevValue != "" {
+		cmps = append(cmps, clientv3.Compare(clientv3.Value(key), "=", prevValue))
+	}
+	return cmps
+}
+
+func (s *v2v3Store) JsonStats() []byte                  { panic("STUB") }
+func (s *v2v3Store) DeleteExpiredKeys(cutoff time.Time) { panic("STUB") }
+
+func (s *v2v3Store) Version() int { return 2 }
+
+// TODO: move this out of the Store interface?
+
+func (s *v2v3Store) Save() ([]byte, error)       { panic("STUB") }
+func (s *v2v3Store) Recovery(state []byte) error { panic("STUB") }
+func (s *v2v3Store) Clone() store.Store          { panic("STUB") }
+func (s *v2v3Store) SaveNoCopy() ([]byte, error) { panic("STUB") }
+func (s *v2v3Store) HasTTLKeys() bool            { panic("STUB") }
+
+func (s *v2v3Store) mkPath(nodePath string) string { return s.mkPathDepth(nodePath, 0) }
+
+func (s *v2v3Store) mkNodePath(p string) string {
+	return path.Clean(p[len(s.pfx)+len("/k/000/"):])
+}
+
+// mkPathDepth makes a path to a key that encodes its directory depth
+// for fast directory listing. If a depth is provided, it is added
+// to the computed depth.
+func (s *v2v3Store) mkPathDepth(nodePath string, depth int) string {
+	normalForm := path.Clean(path.Join("/", nodePath))
+	n := strings.Count(normalForm, "/") + depth
+	return fmt.Sprintf("%s/%03d/k/%s", s.pfx, n, normalForm)
+}
+
+func (s *v2v3Store) mkActionKey() string { return s.pfx + "/act" }
+
+func isRoot(s string) bool { return len(s) == 0 || s == "/" || s == "/0" || s == "/1" }
+
+func mkV2Rev(v3Rev int64) uint64 {
+	if v3Rev == 0 {
+		return 0
+	}
+	return uint64(v3Rev - 1)
+}
+
+func mkV3Rev(v2Rev uint64) int64 {
+	if v2Rev == 0 {
+		return 0
+	}
+	return int64(v2Rev + 1)
+}
+
+// mkV2Node creates a V2 NodeExtern from a V3 KeyValue
+func (s *v2v3Store) mkV2Node(kv *mvccpb.KeyValue) *store.NodeExtern {
+	if kv == nil {
+		return nil
+	}
+	n := &store.NodeExtern{
+		Key:           string(s.mkNodePath(string(kv.Key))),
+		Dir:           kv.Key[len(kv.Key)-1] == '/',
+		CreatedIndex:  mkV2Rev(kv.CreateRevision),
+		ModifiedIndex: mkV2Rev(kv.ModRevision),
+	}
+	if !n.Dir {
+		v := string(kv.Value)
+		n.Value = &v
+	}
+	return n
+}
+
+// prevKeyFromPuts gets the prev key that is being put; ignores
+// the put action response.
+func prevKeyFromPuts(resp *clientv3.TxnResponse) *mvccpb.KeyValue {
+	for _, r := range resp.Responses {
+		pkv := r.GetResponsePut().PrevKv
+		if pkv != nil && pkv.CreateRevision > 0 {
+			return pkv
+		}
+	}
+	return nil
+}
+
+func (s *v2v3Store) newSTM(applyf func(concurrency.STM) error) (*clientv3.TxnResponse, error) {
+	return concurrency.NewSTM(s.c, applyf, concurrency.WithIsolation(concurrency.Serializable))
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/watcher.go b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/watcher.go
new file mode 100644
index 00000000000..1c2680e744a
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v2v3/watcher.go
@@ -0,0 +1,140 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v2v3
+
+import (
+	"context"
+	"strings"
+
+	"github.com/coreos/etcd/clientv3"
+	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/store"
+)
+
+func (s *v2v3Store) Watch(prefix string, recursive, stream bool, sinceIndex uint64) (store.Watcher, error) {
+	ctx, cancel := context.WithCancel(s.ctx)
+	wch := s.c.Watch(
+		ctx,
+		// TODO: very pricey; use a single store-wide watch in future
+		s.pfx,
+		clientv3.WithPrefix(),
+		clientv3.WithRev(int64(sinceIndex)),
+		clientv3.WithCreatedNotify(),
+		clientv3.WithPrevKV())
+	resp, ok := <-wch
+	if err := resp.Err(); err != nil || !ok {
+		cancel()
+		return nil, etcdErr.NewError(etcdErr.EcodeRaftInternal, prefix, 0)
+	}
+
+	evc, donec := make(chan *store.Event), make(chan struct{})
+	go func() {
+		defer func() {
+			close(evc)
+			close(donec)
+		}()
+		for resp := range wch {
+			for _, ev := range s.mkV2Events(resp) {
+				k := ev.Node.Key
+				if recursive {
+					if !strings.HasPrefix(k, prefix) {
+						continue
+					}
+					// accept events on hidden keys given in prefix
+					k = strings.Replace(k, prefix, "/", 1)
+					// ignore hidden keys deeper than prefix
+					if strings.Contains(k, "/_") {
+						continue
+					}
+				}
+				if !recursive && k != prefix {
+					continue
+				}
+				select {
+				case evc <- ev:
+				case <-ctx.Done():
+					return
+				}
+				if !stream {
+					return
+				}
+			}
+		}
+	}()
+
+	return &v2v3Watcher{
+		startRev: resp.Header.Revision,
+		evc:      evc,
+		donec:    donec,
+		cancel:   cancel,
+	}, nil
+}
+
+func (s *v2v3Store) mkV2Events(wr clientv3.WatchResponse) (evs []*store.Event) {
+	ak := s.mkActionKey()
+	for _, rev := range mkRevs(wr) {
+		var act, key *clientv3.Event
+		for _, ev := range rev {
+			if string(ev.Kv.Key) == ak {
+				act = ev
+			} else if key != nil && len(key.Kv.Key) < len(ev.Kv.Key) {
+				// use longest key to ignore intermediate new
+				// directories from Create.
+				key = ev
+			} else if key == nil {
+				key = ev
+			}
+		}
+		v2ev := &store.Event{
+			Action:    string(act.Kv.Value),
+			Node:      s.mkV2Node(key.Kv),
+			PrevNode:  s.mkV2Node(key.PrevKv),
+			EtcdIndex: mkV2Rev(wr.Header.Revision),
+		}
+		evs = append(evs, v2ev)
+	}
+	return evs
+}
+
+func mkRevs(wr clientv3.WatchResponse) (revs [][]*clientv3.Event) {
+	var curRev []*clientv3.Event
+	for _, ev := range wr.Events {
+		if curRev != nil && ev.Kv.ModRevision != curRev[0].Kv.ModRevision {
+			revs = append(revs, curRev)
+			curRev = nil
+		}
+		curRev = append(curRev, ev)
+	}
+	if curRev != nil {
+		revs = append(revs, curRev)
+	}
+	return revs
+}
+
+type v2v3Watcher struct {
+	startRev int64
+	evc      chan *store.Event
+	donec    chan struct{}
+	cancel   context.CancelFunc
+}
+
+func (w *v2v3Watcher) StartIndex() uint64 { return mkV2Rev(w.startRev) }
+
+func (w *v2v3Watcher) Remove() {
+	w.cancel()
+	<-w.donec
+}
+
+func (w *v2v3Watcher) EventChan() chan *store.Event { return w.evc }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3client/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/v3client/BUILD
index 097777cc1e3..ffa04f94780 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3client/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3client/BUILD
@@ -14,7 +14,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/etcdserver:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3rpc:go_default_library",
         "//vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3client/v3client.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3client/v3client.go
index c0c07c8d767..ab48ea75b91 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3client/v3client.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3client/v3client.go
@@ -15,14 +15,13 @@
 package v3client
 
 import (
+	"context"
 	"time"
 
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc"
 	"github.com/coreos/etcd/proxy/grpcproxy/adapter"
-
-	"golang.org/x/net/context"
 )
 
 // New creates a clientv3 client that wraps an in-process EtcdServer. Instead
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/BUILD
index b9f70b79b58..c680d99ca74 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/BUILD
@@ -13,7 +13,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/clientv3:go_default_library",
         "//vendor/github.com/coreos/etcd/clientv3/concurrency:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/election.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/election.go
index d1b2767be3f..c66d7a38290 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/election.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/election.go
@@ -15,10 +15,9 @@
 package v3election
 
 import (
+	"context"
 	"errors"
 
-	"golang.org/x/net/context"
-
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/clientv3/concurrency"
 	epb "github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb"
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/BUILD
index f0deaa9a77e..2b187653b7e 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/BUILD
@@ -9,9 +9,9 @@ go_library(
     deps = [
         "//vendor/github.com/coreos/etcd/etcdserver/etcdserverpb:go_default_library",
         "//vendor/github.com/coreos/etcd/mvcc/mvccpb:go_default_library",
+        "//vendor/github.com/gogo/protobuf/gogoproto:go_default_library",
         "//vendor/github.com/golang/protobuf/proto:go_default_library",
         "//vendor/golang.org/x/net/context:go_default_library",
-        "//vendor/google.golang.org/genproto/googleapis/api/annotations:go_default_library",
         "//vendor/google.golang.org/grpc:go_default_library",
     ],
 )
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/gw/v3election.pb.gw.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/gw/v3election.pb.gw.go
index ac00cbea983..58368bbfb30 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/gw/v3election.pb.gw.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/gw/v3election.pb.gw.go
@@ -141,7 +141,7 @@ func RegisterElectionHandler(ctx context.Context, mux *runtime.ServeMux, conn *g
 func RegisterElectionHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v3electionpb.ElectionClient) error {
 
 	mux.Handle("POST", pattern_Election_Campaign_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -170,7 +170,7 @@ func RegisterElectionHandlerClient(ctx context.Context, mux *runtime.ServeMux, c
 	})
 
 	mux.Handle("POST", pattern_Election_Proclaim_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -199,7 +199,7 @@ func RegisterElectionHandlerClient(ctx context.Context, mux *runtime.ServeMux, c
 	})
 
 	mux.Handle("POST", pattern_Election_Leader_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -228,7 +228,7 @@ func RegisterElectionHandlerClient(ctx context.Context, mux *runtime.ServeMux, c
 	})
 
 	mux.Handle("POST", pattern_Election_Observe_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -257,7 +257,7 @@ func RegisterElectionHandlerClient(ctx context.Context, mux *runtime.ServeMux, c
 	})
 
 	mux.Handle("POST", pattern_Election_Resign_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -289,15 +289,15 @@ func RegisterElectionHandlerClient(ctx context.Context, mux *runtime.ServeMux, c
 }
 
 var (
-	pattern_Election_Campaign_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "election", "campaign"}, ""))
+	pattern_Election_Campaign_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "election", "campaign"}, ""))
 
-	pattern_Election_Proclaim_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "election", "proclaim"}, ""))
+	pattern_Election_Proclaim_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "election", "proclaim"}, ""))
 
-	pattern_Election_Leader_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "election", "leader"}, ""))
+	pattern_Election_Leader_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "election", "leader"}, ""))
 
-	pattern_Election_Observe_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "election", "observe"}, ""))
+	pattern_Election_Observe_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "election", "observe"}, ""))
 
-	pattern_Election_Resign_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "election", "resign"}, ""))
+	pattern_Election_Resign_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "election", "resign"}, ""))
 )
 
 var (
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/v3election.pb.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/v3election.pb.go
index 92acb1469e9..e298e452119 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/v3election.pb.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/v3election.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: v3election.proto
-// DO NOT EDIT!
 
 /*
 	Package v3electionpb is a generated protocol buffer package.
@@ -28,12 +27,12 @@ import (
 
 	math "math"
 
+	_ "github.com/gogo/protobuf/gogoproto"
+
 	etcdserverpb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
 	mvccpb "github.com/coreos/etcd/mvcc/mvccpb"
 
-	_ "google.golang.org/genproto/googleapis/api/annotations"
-
 	context "golang.org/x/net/context"
 
 	grpc "google.golang.org/grpc"
@@ -836,24 +835,6 @@ func (m *ProclaimResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64V3Election(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32V3Election(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintV3Election(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -2060,39 +2041,39 @@ var (
 func init() { proto.RegisterFile("v3election.proto", fileDescriptorV3Election) }
 
 var fileDescriptorV3Election = []byte{
-	// 540 bytes of a gzipped FileDescriptorProto
+	// 538 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xc1, 0x6e, 0xd3, 0x40,
-	0x10, 0x65, 0x9d, 0x10, 0xca, 0x90, 0xb6, 0x96, 0x55, 0x89, 0x34, 0xa4, 0x26, 0xda, 0x02, 0xaa,
-	0x72, 0xf0, 0xa2, 0x86, 0x53, 0x4e, 0x08, 0x04, 0xaa, 0x54, 0x24, 0xc0, 0x07, 0x04, 0xc7, 0x8d,
-	0x3b, 0x4a, 0xa2, 0x38, 0xde, 0xc5, 0x4e, 0x2d, 0xe5, 0xca, 0x2f, 0x70, 0xe1, 0x33, 0xf8, 0x0c,
-	0x8e, 0x48, 0xfc, 0x00, 0x0a, 0x7c, 0x08, 0xda, 0x5d, 0x1b, 0x3b, 0x6e, 0x88, 0x50, 0x73, 0xb1,
-	0xc6, 0x33, 0xcf, 0xf3, 0xe6, 0xbd, 0x9d, 0x35, 0xd8, 0x69, 0x1f, 0x43, 0x0c, 0xe6, 0x13, 0x11,
-	0x79, 0x32, 0x16, 0x73, 0xe1, 0x34, 0x8b, 0x8c, 0x1c, 0xb6, 0x0f, 0x46, 0x62, 0x24, 0x74, 0x81,
-	0xa9, 0xc8, 0x60, 0xda, 0x8f, 0x70, 0x1e, 0x5c, 0x30, 0xf5, 0x48, 0x30, 0x4e, 0x31, 0x2e, 0x85,
-	0x72, 0xc8, 0x62, 0x19, 0x64, 0xb8, 0x43, 0x8d, 0x9b, 0xa5, 0x41, 0xa0, 0x1f, 0x72, 0xc8, 0xa6,
-	0x69, 0x56, 0xea, 0x8c, 0x84, 0x18, 0x85, 0xc8, 0xb8, 0x9c, 0x30, 0x1e, 0x45, 0x62, 0xce, 0x15,
-	0x63, 0x62, 0xaa, 0xf4, 0x2d, 0xec, 0x3f, 0xe7, 0x33, 0xc9, 0x27, 0xa3, 0xc8, 0xc7, 0x8f, 0x97,
-	0x98, 0xcc, 0x1d, 0x07, 0xea, 0x11, 0x9f, 0x61, 0x8b, 0x74, 0xc9, 0x49, 0xd3, 0xd7, 0xb1, 0x73,
-	0x00, 0x37, 0x43, 0xe4, 0x09, 0xb6, 0xac, 0x2e, 0x39, 0xa9, 0xf9, 0xe6, 0x45, 0x65, 0x53, 0x1e,
-	0x5e, 0x62, 0xab, 0xa6, 0xa1, 0xe6, 0x85, 0x2e, 0xc0, 0x2e, 0x5a, 0x26, 0x52, 0x44, 0x09, 0x3a,
-	0x4f, 0xa0, 0x31, 0x46, 0x7e, 0x81, 0xb1, 0xee, 0x7a, 0xe7, 0xb4, 0xe3, 0x95, 0x85, 0x78, 0x39,
-	0xee, 0x4c, 0x63, 0xfc, 0x0c, 0xeb, 0x30, 0x68, 0x84, 0xe6, 0x2b, 0x4b, 0x7f, 0x75, 0xd7, 0x2b,
-	0x5b, 0xe6, 0xbd, 0xd2, 0xb5, 0x73, 0x5c, 0xf8, 0x19, 0x8c, 0x7e, 0x80, 0xdb, 0x7f, 0x93, 0x6b,
-	0x75, 0xd8, 0x50, 0x9b, 0xe2, 0x42, 0xb7, 0x6b, 0xfa, 0x2a, 0x54, 0x99, 0x18, 0x53, 0xad, 0xa0,
-	0xe6, 0xab, 0xb0, 0xd0, 0x5a, 0x2f, 0x69, 0xa5, 0xc7, 0xb0, 0x6b, 0x5a, 0x6f, 0xb0, 0x89, 0x8e,
-	0x61, 0x2f, 0x07, 0x6d, 0x25, 0xbc, 0x0b, 0xd6, 0x34, 0xcd, 0x44, 0xdb, 0x9e, 0x39, 0x51, 0xef,
-	0x1c, 0x17, 0xef, 0x94, 0xc1, 0xbe, 0x35, 0x4d, 0xe9, 0x53, 0xd8, 0xf5, 0x31, 0x29, 0x9d, 0x5a,
-	0xe1, 0x15, 0xf9, 0x3f, 0xaf, 0x5e, 0xc2, 0x5e, 0xde, 0x61, 0x9b, 0x59, 0xe9, 0x7b, 0xd8, 0x7f,
-	0x13, 0x8b, 0x20, 0xe4, 0x93, 0xd9, 0x75, 0x67, 0x29, 0x16, 0xc9, 0x2a, 0x2f, 0xd2, 0x19, 0xd8,
-	0x45, 0xe7, 0x6d, 0x66, 0x3c, 0xfd, 0x5a, 0x87, 0x9d, 0x17, 0xd9, 0x00, 0x8e, 0x84, 0x9d, 0x7c,
-	0x3f, 0x9d, 0xa3, 0xd5, 0xc9, 0x2a, 0x57, 0xa1, 0xed, 0xfe, 0xab, 0x6c, 0x58, 0xe8, 0xc3, 0x4f,
-	0x3f, 0x7e, 0x7f, 0xb6, 0xee, 0xd3, 0x36, 0x4b, 0xfb, 0x3c, 0x94, 0x63, 0xce, 0x72, 0x34, 0x0b,
-	0x32, 0xec, 0x80, 0xf4, 0x14, 0x63, 0x2e, 0xa4, 0xca, 0x58, 0xb1, 0xae, 0xca, 0x58, 0xd5, 0xbf,
-	0x89, 0x51, 0x66, 0x58, 0xc5, 0x38, 0x86, 0x86, 0x71, 0xd9, 0xb9, 0xb7, 0xce, 0xfb, 0x9c, 0xad,
-	0xb3, 0xbe, 0x98, 0x71, 0x1d, 0x6b, 0xae, 0x23, 0xda, 0xba, 0xca, 0x65, 0xce, 0x4d, 0x31, 0x85,
-	0x70, 0xeb, 0xf5, 0x50, 0xfb, 0xbf, 0x0d, 0xd5, 0x03, 0x4d, 0xe5, 0xd2, 0xc3, 0xab, 0x54, 0xc2,
-	0x74, 0x1f, 0x90, 0xde, 0x63, 0xa2, 0x74, 0x99, 0xa5, 0xad, 0x92, 0xad, 0x5c, 0x86, 0x2a, 0xd9,
-	0xea, 0x9e, 0x6f, 0xd2, 0x15, 0x6b, 0xe4, 0x80, 0xf4, 0x9e, 0xd9, 0xdf, 0x96, 0x2e, 0xf9, 0xbe,
-	0x74, 0xc9, 0xcf, 0xa5, 0x4b, 0xbe, 0xfc, 0x72, 0x6f, 0x0c, 0x1b, 0xfa, 0x8f, 0xd9, 0xff, 0x13,
-	0x00, 0x00, 0xff, 0xff, 0xfc, 0x4d, 0x5a, 0x40, 0xca, 0x05, 0x00, 0x00,
+	0x10, 0x65, 0x9d, 0x10, 0xca, 0x90, 0xb6, 0x96, 0x55, 0xa9, 0x69, 0x48, 0xad, 0x68, 0x8b, 0x50,
+	0x95, 0x83, 0x17, 0x35, 0x9c, 0x72, 0x42, 0x20, 0x50, 0xa5, 0x22, 0x01, 0x3e, 0x20, 0x38, 0xae,
+	0xdd, 0x91, 0x1b, 0xc5, 0xf1, 0x1a, 0xdb, 0xb5, 0x94, 0x2b, 0xbf, 0xc0, 0x85, 0x7f, 0xe0, 0x47,
+	0x38, 0x22, 0xf1, 0x03, 0x28, 0xf0, 0x21, 0x68, 0x77, 0x6d, 0xec, 0xb8, 0x21, 0x42, 0xe4, 0x62,
+	0x8d, 0x67, 0x9e, 0xe7, 0xcd, 0x7b, 0x3b, 0x6b, 0x30, 0xf3, 0x31, 0x86, 0xe8, 0x67, 0x53, 0x11,
+	0x39, 0x71, 0x22, 0x32, 0x61, 0x75, 0xab, 0x4c, 0xec, 0xf5, 0x0f, 0x02, 0x11, 0x08, 0x55, 0x60,
+	0x32, 0xd2, 0x98, 0xfe, 0x43, 0xcc, 0xfc, 0x4b, 0x26, 0x1f, 0x29, 0x26, 0x39, 0x26, 0xb5, 0x30,
+	0xf6, 0x58, 0x12, 0xfb, 0x05, 0xee, 0x48, 0xe1, 0xe6, 0xb9, 0xef, 0xab, 0x47, 0xec, 0xb1, 0x59,
+	0x5e, 0x94, 0x06, 0x81, 0x10, 0x41, 0x88, 0x8c, 0xc7, 0x53, 0xc6, 0xa3, 0x48, 0x64, 0x5c, 0x32,
+	0xa6, 0xba, 0x4a, 0xdf, 0xc0, 0xfe, 0x33, 0x3e, 0x8f, 0xf9, 0x34, 0x88, 0x5c, 0xfc, 0x70, 0x8d,
+	0x69, 0x66, 0x59, 0xd0, 0x8e, 0xf8, 0x1c, 0x7b, 0x64, 0x48, 0x4e, 0xbb, 0xae, 0x8a, 0xad, 0x03,
+	0xb8, 0x1d, 0x22, 0x4f, 0xb1, 0x67, 0x0c, 0xc9, 0x69, 0xcb, 0xd5, 0x2f, 0x32, 0x9b, 0xf3, 0xf0,
+	0x1a, 0x7b, 0x2d, 0x05, 0xd5, 0x2f, 0x74, 0x01, 0x66, 0xd5, 0x32, 0x8d, 0x45, 0x94, 0xa2, 0xf5,
+	0x18, 0x3a, 0x57, 0xc8, 0x2f, 0x31, 0x51, 0x5d, 0xef, 0x9d, 0x0d, 0x9c, 0xba, 0x10, 0xa7, 0xc4,
+	0x9d, 0x2b, 0x8c, 0x5b, 0x60, 0x2d, 0x06, 0x9d, 0x50, 0x7f, 0x65, 0xa8, 0xaf, 0x0e, 0x9d, 0xba,
+	0x65, 0xce, 0x4b, 0x55, 0xbb, 0xc0, 0x85, 0x5b, 0xc0, 0xe8, 0x7b, 0xb8, 0xfb, 0x27, 0xb9, 0x56,
+	0x87, 0x09, 0xad, 0x19, 0x2e, 0x54, 0xbb, 0xae, 0x2b, 0x43, 0x99, 0x49, 0x30, 0x57, 0x0a, 0x5a,
+	0xae, 0x0c, 0x2b, 0xad, 0xed, 0x9a, 0x56, 0x7a, 0x02, 0xbb, 0xba, 0xf5, 0x06, 0x9b, 0xe8, 0x15,
+	0xec, 0x95, 0xa0, 0xad, 0x84, 0x0f, 0xc1, 0x98, 0xe5, 0x85, 0x68, 0xd3, 0xd1, 0x27, 0xea, 0x5c,
+	0xe0, 0xe2, 0xad, 0x34, 0xd8, 0x35, 0x66, 0x39, 0x7d, 0x02, 0xbb, 0x2e, 0xa6, 0xb5, 0x53, 0xab,
+	0xbc, 0x22, 0xff, 0xe6, 0xd5, 0x0b, 0xd8, 0x2b, 0x3b, 0x6c, 0x33, 0x2b, 0x7d, 0x07, 0xfb, 0xaf,
+	0x13, 0xe1, 0x87, 0x7c, 0x3a, 0xff, 0xdf, 0x59, 0xaa, 0x45, 0x32, 0xea, 0x8b, 0x74, 0x0e, 0x66,
+	0xd5, 0x79, 0x9b, 0x19, 0xcf, 0xbe, 0xb4, 0x61, 0xe7, 0x79, 0x31, 0x80, 0x25, 0x60, 0xa7, 0xdc,
+	0x4f, 0xeb, 0x78, 0x75, 0xb2, 0xc6, 0x55, 0xe8, 0xdb, 0x7f, 0x2b, 0x6b, 0x16, 0xfa, 0xe0, 0xe3,
+	0xf7, 0x5f, 0x9f, 0x0c, 0x9b, 0x1e, 0xb1, 0x7c, 0xec, 0x61, 0xc6, 0x59, 0x09, 0x66, 0x7e, 0x01,
+	0x9d, 0x90, 0x91, 0x24, 0x2c, 0x75, 0x34, 0x09, 0x1b, 0xce, 0x35, 0x09, 0x9b, 0xf2, 0x37, 0x10,
+	0xc6, 0x05, 0x54, 0x12, 0x06, 0xd0, 0xd1, 0x1e, 0x5b, 0xf7, 0xd7, 0x39, 0x5f, 0x92, 0x0d, 0xd6,
+	0x17, 0x0b, 0x2a, 0xaa, 0xa8, 0x06, 0xf4, 0xf0, 0x06, 0x95, 0x3e, 0x34, 0x49, 0x34, 0x83, 0x3b,
+	0xaf, 0x3c, 0x65, 0xfe, 0x36, 0x4c, 0x27, 0x8a, 0xe9, 0x98, 0xf6, 0x6e, 0x30, 0x09, 0xdd, 0x7c,
+	0x42, 0x46, 0x8f, 0x88, 0x54, 0xa5, 0x17, 0xb6, 0xc9, 0xb5, 0x72, 0x11, 0x9a, 0x5c, 0xab, 0x3b,
+	0xbe, 0x41, 0x55, 0xa2, 0x80, 0x13, 0x32, 0x7a, 0x6a, 0x7e, 0x5d, 0xda, 0xe4, 0xdb, 0xd2, 0x26,
+	0x3f, 0x96, 0x36, 0xf9, 0xfc, 0xd3, 0xbe, 0xe5, 0x75, 0xd4, 0xcf, 0x72, 0xfc, 0x3b, 0x00, 0x00,
+	0xff, 0xff, 0xdc, 0xa9, 0x0e, 0xdf, 0xc5, 0x05, 0x00, 0x00,
 }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/v3election.proto b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/v3election.proto
index ebf6c88f7fa..cb475b820dd 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/v3election.proto
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb/v3election.proto
@@ -19,21 +19,21 @@ service Election {
   // leadership still being held, and resign from the election.
   rpc Campaign(CampaignRequest) returns (CampaignResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/election/campaign"
+        post: "/v3beta/election/campaign"
         body: "*"
     };
   }
   // Proclaim updates the leader's posted value with a new value.
   rpc Proclaim(ProclaimRequest) returns (ProclaimResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/election/proclaim"
+        post: "/v3beta/election/proclaim"
         body: "*"
     };
   }
   // Leader returns the current election proclamation, if any.
   rpc Leader(LeaderRequest) returns (LeaderResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/election/leader"
+        post: "/v3beta/election/leader"
         body: "*"
     };
   }
@@ -41,7 +41,7 @@ service Election {
   // elected leaders.
   rpc Observe(LeaderRequest) returns (stream LeaderResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/election/observe"
+        post: "/v3beta/election/observe"
         body: "*"
     };
   }
@@ -49,7 +49,7 @@ service Election {
   // leadership on the election.
   rpc Resign(ResignRequest) returns (ResignResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/election/resign"
+        post: "/v3beta/election/resign"
         body: "*"
     };
   }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/BUILD
index 27f6d766f3b..763ed811a4b 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/BUILD
@@ -13,7 +13,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/clientv3:go_default_library",
         "//vendor/github.com/coreos/etcd/clientv3/concurrency:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/lock.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/lock.go
index 66465bf13f6..a5efcbab5b5 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/lock.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/lock.go
@@ -15,7 +15,7 @@
 package v3lock
 
 import (
-	"golang.org/x/net/context"
+	"context"
 
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/clientv3/concurrency"
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/BUILD
index edf5c561af2..d39d10d1eea 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/BUILD
@@ -8,9 +8,9 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//vendor/github.com/coreos/etcd/etcdserver/etcdserverpb:go_default_library",
+        "//vendor/github.com/gogo/protobuf/gogoproto:go_default_library",
         "//vendor/github.com/golang/protobuf/proto:go_default_library",
         "//vendor/golang.org/x/net/context:go_default_library",
-        "//vendor/google.golang.org/genproto/googleapis/api/annotations:go_default_library",
         "//vendor/google.golang.org/grpc:go_default_library",
     ],
 )
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/gw/v3lock.pb.gw.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/gw/v3lock.pb.gw.go
index 5aef4756dfe..efecc45dba3 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/gw/v3lock.pb.gw.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/gw/v3lock.pb.gw.go
@@ -94,7 +94,7 @@ func RegisterLockHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.
 func RegisterLockHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v3lockpb.LockClient) error {
 
 	mux.Handle("POST", pattern_Lock_Lock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -123,7 +123,7 @@ func RegisterLockHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Lock_Unlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -155,9 +155,9 @@ func RegisterLockHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 }
 
 var (
-	pattern_Lock_Lock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1}, []string{"v3alpha", "lock"}, ""))
+	pattern_Lock_Lock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1}, []string{"v3beta", "lock"}, ""))
 
-	pattern_Lock_Unlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "lock", "unlock"}, ""))
+	pattern_Lock_Unlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "lock", "unlock"}, ""))
 )
 
 var (
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/v3lock.pb.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/v3lock.pb.go
index dcf2bad4019..071d0ae242b 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/v3lock.pb.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/v3lock.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: v3lock.proto
-// DO NOT EDIT!
 
 /*
 	Package v3lockpb is a generated protocol buffer package.
@@ -23,9 +22,9 @@ import (
 
 	math "math"
 
-	etcdserverpb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	_ "github.com/gogo/protobuf/gogoproto"
 
-	_ "google.golang.org/genproto/googleapis/api/annotations"
+	etcdserverpb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
 	context "golang.org/x/net/context"
 
@@ -380,24 +379,6 @@ func (m *UnlockResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64V3Lock(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32V3Lock(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintV3Lock(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -953,7 +934,7 @@ var (
 func init() { proto.RegisterFile("v3lock.proto", fileDescriptorV3Lock) }
 
 var fileDescriptorV3Lock = []byte{
-	// 336 bytes of a gzipped FileDescriptorProto
+	// 335 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x33, 0xce, 0xc9,
 	0x4f, 0xce, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x80, 0xf0, 0x0a, 0x92, 0xa4, 0x44,
 	0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x82, 0xfa, 0x20, 0x16, 0x44, 0x5e, 0x4a, 0x2d, 0xb5, 0x24, 0x39,
@@ -967,12 +948,12 @@ var fileDescriptorV3Lock = []byte{
 	0x98, 0x92, 0x5a, 0x04, 0xd6, 0xcb, 0x6d, 0x24, 0xa3, 0x87, 0xec, 0x1e, 0x3d, 0x98, 0x3a, 0x0f,
 	0xb0, 0x9a, 0x20, 0xa8, 0x5a, 0x21, 0x01, 0x2e, 0xe6, 0xec, 0xd4, 0x4a, 0xb0, 0xc9, 0x3c, 0x41,
 	0x20, 0xa6, 0x92, 0x22, 0x17, 0x6f, 0x68, 0x5e, 0x0e, 0x92, 0x93, 0xa0, 0x4a, 0x18, 0x11, 0x4a,
-	0xdc, 0xb8, 0xf8, 0x60, 0x4a, 0x28, 0xb1, 0xdc, 0x68, 0x17, 0x23, 0x17, 0x0b, 0xc8, 0x0f, 0x42,
-	0x21, 0x50, 0x5a, 0x54, 0x0f, 0x16, 0xe6, 0x7a, 0x48, 0x81, 0x22, 0x25, 0x86, 0x2e, 0x0c, 0x31,
-	0x4d, 0x49, 0xb6, 0xe9, 0xf2, 0x93, 0xc9, 0x4c, 0xe2, 0x4a, 0x42, 0xfa, 0x65, 0xc6, 0x89, 0x39,
-	0x05, 0x19, 0x89, 0xfa, 0x20, 0x55, 0x60, 0xc2, 0x8a, 0x51, 0x4b, 0x28, 0x86, 0x8b, 0x0d, 0xe2,
-	0x4c, 0x21, 0x71, 0x84, 0x01, 0x28, 0x7e, 0x93, 0x92, 0xc0, 0x94, 0x80, 0x9a, 0x2d, 0x0f, 0x36,
-	0x5b, 0x52, 0x49, 0x04, 0xd5, 0xec, 0xd2, 0x3c, 0xa8, 0xe9, 0x4e, 0x02, 0x27, 0x1e, 0xc9, 0x31,
-	0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x8c, 0xc7, 0x72, 0x0c, 0x49, 0x6c, 0xe0,
-	0x18, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xb6, 0xa0, 0x26, 0x28, 0x47, 0x02, 0x00, 0x00,
+	0xdc, 0xb8, 0xf8, 0x60, 0x4a, 0x28, 0xb1, 0xdc, 0x68, 0x07, 0x23, 0x17, 0x0b, 0xc8, 0x0f, 0x42,
+	0xc1, 0x50, 0x5a, 0x54, 0x0f, 0x16, 0xe6, 0x7a, 0x48, 0x81, 0x22, 0x25, 0x86, 0x2e, 0x0c, 0x31,
+	0x4d, 0x49, 0xa6, 0xe9, 0xf2, 0x93, 0xc9, 0x4c, 0x62, 0x4a, 0x82, 0xfa, 0x65, 0xc6, 0x49, 0xa9,
+	0x25, 0x89, 0xfa, 0x20, 0x45, 0x60, 0xc2, 0x8a, 0x51, 0x4b, 0x28, 0x9a, 0x8b, 0x0d, 0xe2, 0x4a,
+	0x21, 0x71, 0x84, 0x7e, 0x14, 0xaf, 0x49, 0x49, 0x60, 0x4a, 0x40, 0x8d, 0x96, 0x03, 0x1b, 0x2d,
+	0xa1, 0x24, 0x8c, 0x62, 0x74, 0x69, 0x1e, 0xd4, 0x70, 0x27, 0x81, 0x13, 0x8f, 0xe4, 0x18, 0x2f,
+	0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc6, 0x63, 0x39, 0x86, 0x24, 0x36, 0x70, 0x7c,
+	0x1a, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x10, 0x82, 0x89, 0xf0, 0x45, 0x02, 0x00, 0x00,
 }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/v3lock.proto b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/v3lock.proto
index 3e92a6ec277..44b698d66bd 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/v3lock.proto
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb/v3lock.proto
@@ -20,7 +20,7 @@ service Lock {
   // lease associate with the owner expires.
   rpc Lock(LockRequest) returns (LockResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/lock/lock"
+        post: "/v3beta/lock/lock"
         body: "*"
     };
   }
@@ -30,7 +30,7 @@ service Lock {
   // ownership of the lock.
   rpc Unlock(UnlockRequest) returns (UnlockResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/lock/unlock"
+        post: "/v3beta/lock/unlock"
         body: "*"
     };
   }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/BUILD
index 470049931a0..6ef688720bf 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/BUILD
@@ -31,6 +31,7 @@ go_library(
         "//vendor/github.com/coreos/etcd/mvcc:go_default_library",
         "//vendor/github.com/coreos/etcd/mvcc/backend:go_default_library",
         "//vendor/github.com/coreos/etcd/mvcc/mvccpb:go_default_library",
+        "//vendor/github.com/coreos/etcd/pkg/adt:go_default_library",
         "//vendor/github.com/coreos/etcd/pkg/types:go_default_library",
         "//vendor/github.com/coreos/etcd/raft:go_default_library",
         "//vendor/github.com/coreos/etcd/version:go_default_library",
@@ -38,11 +39,12 @@ go_library(
         "//vendor/github.com/gogo/protobuf/proto:go_default_library",
         "//vendor/github.com/grpc-ecosystem/go-grpc-prometheus:go_default_library",
         "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
         "//vendor/google.golang.org/grpc:go_default_library",
         "//vendor/google.golang.org/grpc/codes:go_default_library",
         "//vendor/google.golang.org/grpc/credentials:go_default_library",
         "//vendor/google.golang.org/grpc/grpclog:go_default_library",
+        "//vendor/google.golang.org/grpc/health:go_default_library",
+        "//vendor/google.golang.org/grpc/health/grpc_health_v1:go_default_library",
         "//vendor/google.golang.org/grpc/metadata:go_default_library",
         "//vendor/google.golang.org/grpc/status:go_default_library",
     ],
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/auth.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/auth.go
index e66c5261d0a..ca8e53ad049 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/auth.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/auth.go
@@ -15,9 +15,10 @@
 package v3rpc
 
 import (
+	"context"
+
 	"github.com/coreos/etcd/etcdserver"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	"golang.org/x/net/context"
 )
 
 type AuthServer struct {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/grpc.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/grpc.go
index 5333491a2e2..39776b444d1 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/grpc.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/grpc.go
@@ -23,9 +23,13 @@ import (
 
 	"github.com/coreos/etcd/etcdserver"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+
+	"github.com/grpc-ecosystem/go-grpc-prometheus"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/health"
+	healthpb "google.golang.org/grpc/health/grpc_health_v1"
 )
 
 const (
@@ -57,6 +61,16 @@ func Server(s *etcdserver.EtcdServer, tls *tls.Config, gopts ...grpc.ServerOptio
 	pb.RegisterAuthServer(grpcServer, NewAuthServer(s))
 	pb.RegisterMaintenanceServer(grpcServer, NewMaintenanceServer(s))
 
+	// server should register all the services manually
+	// use empty service name for all etcd services' health status,
+	// see https://github.com/grpc/grpc/blob/master/doc/health-checking.md for more
+	hsrv := health.NewServer()
+	hsrv.SetServingStatus("", healthpb.HealthCheckResponse_SERVING)
+	healthpb.RegisterHealthServer(grpcServer, hsrv)
+
+	// set zero values for metrics registered for this grpc server
+	grpc_prometheus.Register(grpcServer)
+
 	grpclogOnce.Do(func() {
 		if s.Cfg.Debug {
 			grpc.EnableTracing = true
@@ -67,5 +81,6 @@ func Server(s *etcdserver.EtcdServer, tls *tls.Config, gopts ...grpc.ServerOptio
 			grpclog.SetLoggerV2(grpclog.NewLoggerV2(ioutil.Discard, os.Stderr, os.Stderr))
 		}
 	})
+
 	return grpcServer
 }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/header.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/header.go
index d6d7f35d50f..75da52fb8d1 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/header.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/header.go
@@ -37,6 +37,9 @@ func newHeader(s *etcdserver.EtcdServer) header {
 
 // fill populates pb.ResponseHeader using etcdserver information
 func (h *header) fill(rh *pb.ResponseHeader) {
+	if rh == nil {
+		plog.Panic("unexpected nil resp.Header")
+	}
 	rh.ClusterId = uint64(h.clusterID)
 	rh.MemberId = uint64(h.memberID)
 	rh.RaftTerm = h.raftTimer.Term()
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/interceptor.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/interceptor.go
index de9470a8905..f38dc4a99cf 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/interceptor.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/interceptor.go
@@ -15,6 +15,7 @@
 package v3rpc
 
 import (
+	"context"
 	"sync"
 	"time"
 
@@ -25,7 +26,6 @@ import (
 	"github.com/coreos/etcd/raft"
 
 	prometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"
 )
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/key.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/key.go
index d0220e03a26..9781bddda9c 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/key.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/key.go
@@ -16,30 +16,32 @@
 package v3rpc
 
 import (
-	"sort"
+	"context"
 
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/pkg/adt"
+
 	"github.com/coreos/pkg/capnslog"
-	"golang.org/x/net/context"
 )
 
 var (
 	plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "etcdserver/api/v3rpc")
-
-	// Max operations per txn list. For example, Txn.Success can have at most 128 operations,
-	// and Txn.Failure can have at most 128 operations.
-	MaxOpsPerTxn = 128
 )
 
 type kvServer struct {
 	hdr header
 	kv  etcdserver.RaftKV
+	// maxTxnOps is the max operations per txn.
+	// e.g suppose maxTxnOps = 128.
+	// Txn.Success can have at most 128 operations,
+	// and Txn.Failure can have at most 128 operations.
+	maxTxnOps uint
 }
 
 func NewKVServer(s *etcdserver.EtcdServer) pb.KVServer {
-	return &kvServer{hdr: newHeader(s), kv: s}
+	return &kvServer{hdr: newHeader(s), kv: s, maxTxnOps: s.Cfg.MaxTxnOps}
 }
 
 func (s *kvServer) Range(ctx context.Context, r *pb.RangeRequest) (*pb.RangeResponse, error) {
@@ -52,9 +54,6 @@ func (s *kvServer) Range(ctx context.Context, r *pb.RangeRequest) (*pb.RangeResp
 		return nil, togRPCError(err)
 	}
 
-	if resp.Header == nil {
-		plog.Panic("unexpected nil resp.Header")
-	}
 	s.hdr.fill(resp.Header)
 	return resp, nil
 }
@@ -69,9 +68,6 @@ func (s *kvServer) Put(ctx context.Context, r *pb.PutRequest) (*pb.PutResponse,
 		return nil, togRPCError(err)
 	}
 
-	if resp.Header == nil {
-		plog.Panic("unexpected nil resp.Header")
-	}
 	s.hdr.fill(resp.Header)
 	return resp, nil
 }
@@ -86,15 +82,19 @@ func (s *kvServer) DeleteRange(ctx context.Context, r *pb.DeleteRangeRequest) (*
 		return nil, togRPCError(err)
 	}
 
-	if resp.Header == nil {
-		plog.Panic("unexpected nil resp.Header")
-	}
 	s.hdr.fill(resp.Header)
 	return resp, nil
 }
 
 func (s *kvServer) Txn(ctx context.Context, r *pb.TxnRequest) (*pb.TxnResponse, error) {
-	if err := checkTxnRequest(r); err != nil {
+	if err := checkTxnRequest(r, int(s.maxTxnOps)); err != nil {
+		return nil, err
+	}
+	// check for forbidden put/del overlaps after checking request to avoid quadratic blowup
+	if _, _, err := checkIntervals(r.Success); err != nil {
+		return nil, err
+	}
+	if _, _, err := checkIntervals(r.Failure); err != nil {
 		return nil, err
 	}
 
@@ -103,9 +103,6 @@ func (s *kvServer) Txn(ctx context.Context, r *pb.TxnRequest) (*pb.TxnResponse,
 		return nil, togRPCError(err)
 	}
 
-	if resp.Header == nil {
-		plog.Panic("unexpected nil resp.Header")
-	}
 	s.hdr.fill(resp.Header)
 	return resp, nil
 }
@@ -116,9 +113,6 @@ func (s *kvServer) Compact(ctx context.Context, r *pb.CompactionRequest) (*pb.Co
 		return nil, togRPCError(err)
 	}
 
-	if resp.Header == nil {
-		plog.Panic("unexpected nil resp.Header")
-	}
 	s.hdr.fill(resp.Header)
 	return resp, nil
 }
@@ -150,8 +144,15 @@ func checkDeleteRequest(r *pb.DeleteRangeRequest) error {
 	return nil
 }
 
-func checkTxnRequest(r *pb.TxnRequest) error {
-	if len(r.Compare) > MaxOpsPerTxn || len(r.Success) > MaxOpsPerTxn || len(r.Failure) > MaxOpsPerTxn {
+func checkTxnRequest(r *pb.TxnRequest, maxTxnOps int) error {
+	opc := len(r.Compare)
+	if opc < len(r.Success) {
+		opc = len(r.Success)
+	}
+	if opc < len(r.Failure) {
+		opc = len(r.Failure)
+	}
+	if opc > maxTxnOps {
 		return rpctypes.ErrGRPCTooManyOps
 	}
 
@@ -160,58 +161,29 @@ func checkTxnRequest(r *pb.TxnRequest) error {
 			return rpctypes.ErrGRPCEmptyKey
 		}
 	}
-
 	for _, u := range r.Success {
-		if err := checkRequestOp(u); err != nil {
+		if err := checkRequestOp(u, maxTxnOps-opc); err != nil {
 			return err
 		}
 	}
-	if err := checkRequestDupKeys(r.Success); err != nil {
-		return err
+	for _, u := range r.Failure {
+		if err := checkRequestOp(u, maxTxnOps-opc); err != nil {
+			return err
+		}
 	}
 
-	for _, u := range r.Failure {
-		if err := checkRequestOp(u); err != nil {
-			return err
-		}
-	}
-	return checkRequestDupKeys(r.Failure)
+	return nil
 }
 
-// checkRequestDupKeys gives rpctypes.ErrGRPCDuplicateKey if the same key is modified twice
-func checkRequestDupKeys(reqs []*pb.RequestOp) error {
-	// check put overlap
-	keys := make(map[string]struct{})
-	for _, requ := range reqs {
-		tv, ok := requ.Request.(*pb.RequestOp_RequestPut)
-		if !ok {
-			continue
-		}
-		preq := tv.RequestPut
-		if preq == nil {
-			continue
-		}
-		if _, ok := keys[string(preq.Key)]; ok {
-			return rpctypes.ErrGRPCDuplicateKey
-		}
-		keys[string(preq.Key)] = struct{}{}
-	}
+// checkIntervals tests whether puts and deletes overlap for a list of ops. If
+// there is an overlap, returns an error. If no overlap, return put and delete
+// sets for recursive evaluation.
+func checkIntervals(reqs []*pb.RequestOp) (map[string]struct{}, adt.IntervalTree, error) {
+	var dels adt.IntervalTree
 
-	// no need to check deletes if no puts; delete overlaps are permitted
-	if len(keys) == 0 {
-		return nil
-	}
-
-	// sort keys for range checking
-	sortedKeys := []string{}
-	for k := range keys {
-		sortedKeys = append(sortedKeys, k)
-	}
-	sort.Strings(sortedKeys)
-
-	// check put overlap with deletes
-	for _, requ := range reqs {
-		tv, ok := requ.Request.(*pb.RequestOp_RequestDeleteRange)
+	// collect deletes from this level; build first to check lower level overlapped puts
+	for _, req := range reqs {
+		tv, ok := req.Request.(*pb.RequestOp_RequestDeleteRange)
 		if !ok {
 			continue
 		}
@@ -219,41 +191,87 @@ func checkRequestDupKeys(reqs []*pb.RequestOp) error {
 		if dreq == nil {
 			continue
 		}
-		if dreq.RangeEnd == nil {
-			if _, found := keys[string(dreq.Key)]; found {
-				return rpctypes.ErrGRPCDuplicateKey
-			}
+		var iv adt.Interval
+		if len(dreq.RangeEnd) != 0 {
+			iv = adt.NewStringAffineInterval(string(dreq.Key), string(dreq.RangeEnd))
 		} else {
-			lo := sort.SearchStrings(sortedKeys, string(dreq.Key))
-			hi := sort.SearchStrings(sortedKeys, string(dreq.RangeEnd))
-			if lo != hi {
-				// element between lo and hi => overlap
-				return rpctypes.ErrGRPCDuplicateKey
-			}
+			iv = adt.NewStringAffinePoint(string(dreq.Key))
 		}
+		dels.Insert(iv, struct{}{})
 	}
 
-	return nil
+	// collect children puts/deletes
+	puts := make(map[string]struct{})
+	for _, req := range reqs {
+		tv, ok := req.Request.(*pb.RequestOp_RequestTxn)
+		if !ok {
+			continue
+		}
+		putsThen, delsThen, err := checkIntervals(tv.RequestTxn.Success)
+		if err != nil {
+			return nil, dels, err
+		}
+		putsElse, delsElse, err := checkIntervals(tv.RequestTxn.Failure)
+		if err != nil {
+			return nil, dels, err
+		}
+		for k := range putsThen {
+			if _, ok := puts[k]; ok {
+				return nil, dels, rpctypes.ErrGRPCDuplicateKey
+			}
+			if dels.Intersects(adt.NewStringAffinePoint(k)) {
+				return nil, dels, rpctypes.ErrGRPCDuplicateKey
+			}
+			puts[k] = struct{}{}
+		}
+		for k := range putsElse {
+			if _, ok := puts[k]; ok {
+				// if key is from putsThen, overlap is OK since
+				// either then/else are mutually exclusive
+				if _, isSafe := putsThen[k]; !isSafe {
+					return nil, dels, rpctypes.ErrGRPCDuplicateKey
+				}
+			}
+			if dels.Intersects(adt.NewStringAffinePoint(k)) {
+				return nil, dels, rpctypes.ErrGRPCDuplicateKey
+			}
+			puts[k] = struct{}{}
+		}
+		dels.Union(delsThen, adt.NewStringAffineInterval("\x00", ""))
+		dels.Union(delsElse, adt.NewStringAffineInterval("\x00", ""))
+	}
+
+	// collect and check this level's puts
+	for _, req := range reqs {
+		tv, ok := req.Request.(*pb.RequestOp_RequestPut)
+		if !ok || tv.RequestPut == nil {
+			continue
+		}
+		k := string(tv.RequestPut.Key)
+		if _, ok := puts[k]; ok {
+			return nil, dels, rpctypes.ErrGRPCDuplicateKey
+		}
+		if dels.Intersects(adt.NewStringAffinePoint(k)) {
+			return nil, dels, rpctypes.ErrGRPCDuplicateKey
+		}
+		puts[k] = struct{}{}
+	}
+	return puts, dels, nil
 }
 
-func checkRequestOp(u *pb.RequestOp) error {
+func checkRequestOp(u *pb.RequestOp, maxTxnOps int) error {
 	// TODO: ensure only one of the field is set.
 	switch uv := u.Request.(type) {
 	case *pb.RequestOp_RequestRange:
-		if uv.RequestRange != nil {
-			return checkRangeRequest(uv.RequestRange)
-		}
+		return checkRangeRequest(uv.RequestRange)
 	case *pb.RequestOp_RequestPut:
-		if uv.RequestPut != nil {
-			return checkPutRequest(uv.RequestPut)
-		}
+		return checkPutRequest(uv.RequestPut)
 	case *pb.RequestOp_RequestDeleteRange:
-		if uv.RequestDeleteRange != nil {
-			return checkDeleteRequest(uv.RequestDeleteRange)
-		}
+		return checkDeleteRequest(uv.RequestDeleteRange)
+	case *pb.RequestOp_RequestTxn:
+		return checkTxnRequest(uv.RequestTxn, maxTxnOps)
 	default:
 		// empty op / nil entry
 		return rpctypes.ErrGRPCKeyNotFound
 	}
-	return nil
 }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/lease.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/lease.go
index fd27d10c02b..5b4f2b14228 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/lease.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/lease.go
@@ -15,13 +15,13 @@
 package v3rpc
 
 import (
+	"context"
 	"io"
 
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/lease"
-	"golang.org/x/net/context"
 )
 
 type LeaseServer struct {
@@ -68,6 +68,21 @@ func (ls *LeaseServer) LeaseTimeToLive(ctx context.Context, rr *pb.LeaseTimeToLi
 	return resp, nil
 }
 
+func (ls *LeaseServer) LeaseLeases(ctx context.Context, rr *pb.LeaseLeasesRequest) (*pb.LeaseLeasesResponse, error) {
+	resp, err := ls.le.LeaseLeases(ctx, rr)
+	if err != nil && err != lease.ErrLeaseNotFound {
+		return nil, togRPCError(err)
+	}
+	if err == lease.ErrLeaseNotFound {
+		resp = &pb.LeaseLeasesResponse{
+			Header: &pb.ResponseHeader{},
+			Leases: []*pb.LeaseStatus{},
+		}
+	}
+	ls.hdr.fill(resp.Header)
+	return resp, nil
+}
+
 func (ls *LeaseServer) LeaseKeepAlive(stream pb.Lease_LeaseKeepAliveServer) (err error) {
 	errc := make(chan error, 1)
 	go func() {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/maintenance.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/maintenance.go
index 3657d036082..c9df1800db2 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/maintenance.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/maintenance.go
@@ -15,17 +15,18 @@
 package v3rpc
 
 import (
+	"context"
 	"crypto/sha256"
 	"io"
 
 	"github.com/coreos/etcd/auth"
 	"github.com/coreos/etcd/etcdserver"
+	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/mvcc"
 	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/pkg/types"
 	"github.com/coreos/etcd/version"
-	"golang.org/x/net/context"
 )
 
 type KVGetter interface {
@@ -40,9 +41,13 @@ type Alarmer interface {
 	Alarm(ctx context.Context, ar *pb.AlarmRequest) (*pb.AlarmResponse, error)
 }
 
+type LeaderTransferrer interface {
+	MoveLeader(ctx context.Context, lead, target uint64) error
+}
+
 type RaftStatusGetter interface {
-	Index() uint64
-	Term() uint64
+	etcdserver.RaftTimer
+	ID() types.ID
 	Leader() types.ID
 }
 
@@ -56,11 +61,12 @@ type maintenanceServer struct {
 	kg  KVGetter
 	bg  BackendGetter
 	a   Alarmer
+	lt  LeaderTransferrer
 	hdr header
 }
 
 func NewMaintenanceServer(s *etcdserver.EtcdServer) pb.MaintenanceServer {
-	srv := &maintenanceServer{rg: s, kg: s, bg: s, a: s, hdr: newHeader(s)}
+	srv := &maintenanceServer{rg: s, kg: s, bg: s, a: s, lt: s, hdr: newHeader(s)}
 	return &authMaintenanceServer{srv, s}
 }
 
@@ -130,6 +136,17 @@ func (ms *maintenanceServer) Hash(ctx context.Context, r *pb.HashRequest) (*pb.H
 	return resp, nil
 }
 
+func (ms *maintenanceServer) HashKV(ctx context.Context, r *pb.HashKVRequest) (*pb.HashKVResponse, error) {
+	h, rev, compactRev, err := ms.kg.KV().HashByRev(r.Revision)
+	if err != nil {
+		return nil, togRPCError(err)
+	}
+
+	resp := &pb.HashKVResponse{Header: &pb.ResponseHeader{Revision: rev}, Hash: h, CompactRevision: compactRev}
+	ms.hdr.fill(resp.Header)
+	return resp, nil
+}
+
 func (ms *maintenanceServer) Alarm(ctx context.Context, ar *pb.AlarmRequest) (*pb.AlarmResponse, error) {
 	return ms.a.Alarm(ctx, ar)
 }
@@ -147,6 +164,17 @@ func (ms *maintenanceServer) Status(ctx context.Context, ar *pb.StatusRequest) (
 	return resp, nil
 }
 
+func (ms *maintenanceServer) MoveLeader(ctx context.Context, tr *pb.MoveLeaderRequest) (*pb.MoveLeaderResponse, error) {
+	if ms.rg.ID() != ms.rg.Leader() {
+		return nil, rpctypes.ErrGRPCNotLeader
+	}
+
+	if err := ms.lt.MoveLeader(ctx, uint64(ms.rg.Leader()), tr.TargetID); err != nil {
+		return nil, togRPCError(err)
+	}
+	return &pb.MoveLeaderResponse{}, nil
+}
+
 type authMaintenanceServer struct {
 	*maintenanceServer
 	ag AuthGetter
@@ -185,6 +213,17 @@ func (ams *authMaintenanceServer) Hash(ctx context.Context, r *pb.HashRequest) (
 	return ams.maintenanceServer.Hash(ctx, r)
 }
 
+func (ams *authMaintenanceServer) HashKV(ctx context.Context, r *pb.HashKVRequest) (*pb.HashKVResponse, error) {
+	if err := ams.isAuthenticated(ctx); err != nil {
+		return nil, err
+	}
+	return ams.maintenanceServer.HashKV(ctx, r)
+}
+
 func (ams *authMaintenanceServer) Status(ctx context.Context, ar *pb.StatusRequest) (*pb.StatusResponse, error) {
 	return ams.maintenanceServer.Status(ctx, ar)
 }
+
+func (ams *authMaintenanceServer) MoveLeader(ctx context.Context, tr *pb.MoveLeaderRequest) (*pb.MoveLeaderResponse, error) {
+	return ams.maintenanceServer.MoveLeader(ctx, tr)
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/member.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/member.go
index 91a59389b87..cbe7b470ab9 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/member.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/member.go
@@ -15,6 +15,7 @@
 package v3rpc
 
 import (
+	"context"
 	"time"
 
 	"github.com/coreos/etcd/etcdserver"
@@ -23,20 +24,17 @@ import (
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/etcdserver/membership"
 	"github.com/coreos/etcd/pkg/types"
-	"golang.org/x/net/context"
 )
 
 type ClusterServer struct {
-	cluster   api.Cluster
-	server    etcdserver.Server
-	raftTimer etcdserver.RaftTimer
+	cluster api.Cluster
+	server  etcdserver.ServerV3
 }
 
-func NewClusterServer(s *etcdserver.EtcdServer) *ClusterServer {
+func NewClusterServer(s etcdserver.ServerV3) *ClusterServer {
 	return &ClusterServer{
-		cluster:   s.Cluster(),
-		server:    s,
-		raftTimer: s,
+		cluster: s.Cluster(),
+		server:  s,
 	}
 }
 
@@ -86,7 +84,7 @@ func (cs *ClusterServer) MemberList(ctx context.Context, r *pb.MemberListRequest
 }
 
 func (cs *ClusterServer) header() *pb.ResponseHeader {
-	return &pb.ResponseHeader{ClusterId: uint64(cs.cluster.ID()), MemberId: uint64(cs.server.ID()), RaftTerm: cs.raftTimer.Term()}
+	return &pb.ResponseHeader{ClusterId: uint64(cs.cluster.ID()), MemberId: uint64(cs.server.ID()), RaftTerm: cs.server.Term()}
 }
 
 func membersToProtoMembers(membs []*membership.Member) []*pb.Member {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/quota.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/quota.go
index 836f2fd3f43..02d99609d88 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/quota.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/quota.go
@@ -15,11 +15,12 @@
 package v3rpc
 
 import (
+	"context"
+
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/pkg/types"
-	"golang.org/x/net/context"
 )
 
 type quotaKVServer struct {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/BUILD b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/BUILD
index 8604a021f6e..7086d87bd76 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/BUILD
@@ -11,7 +11,6 @@ go_library(
     importpath = "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes",
     visibility = ["//visibility:public"],
     deps = [
-        "//vendor/google.golang.org/grpc:go_default_library",
         "//vendor/google.golang.org/grpc/codes:go_default_library",
         "//vendor/google.golang.org/grpc/status:go_default_library",
     ],
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/error.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/error.go
index 9a2ad74a197..55eab38ef17 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/error.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/error.go
@@ -15,109 +15,114 @@
 package rpctypes
 
 import (
-	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
+// server-side error
 var (
-	// server-side error
-	ErrGRPCEmptyKey      = grpc.Errorf(codes.InvalidArgument, "etcdserver: key is not provided")
-	ErrGRPCKeyNotFound   = grpc.Errorf(codes.InvalidArgument, "etcdserver: key not found")
-	ErrGRPCValueProvided = grpc.Errorf(codes.InvalidArgument, "etcdserver: value is provided")
-	ErrGRPCLeaseProvided = grpc.Errorf(codes.InvalidArgument, "etcdserver: lease is provided")
-	ErrGRPCTooManyOps    = grpc.Errorf(codes.InvalidArgument, "etcdserver: too many operations in txn request")
-	ErrGRPCDuplicateKey  = grpc.Errorf(codes.InvalidArgument, "etcdserver: duplicate key given in txn request")
-	ErrGRPCCompacted     = grpc.Errorf(codes.OutOfRange, "etcdserver: mvcc: required revision has been compacted")
-	ErrGRPCFutureRev     = grpc.Errorf(codes.OutOfRange, "etcdserver: mvcc: required revision is a future revision")
-	ErrGRPCNoSpace       = grpc.Errorf(codes.ResourceExhausted, "etcdserver: mvcc: database space exceeded")
+	ErrGRPCEmptyKey      = status.New(codes.InvalidArgument, "etcdserver: key is not provided").Err()
+	ErrGRPCKeyNotFound   = status.New(codes.InvalidArgument, "etcdserver: key not found").Err()
+	ErrGRPCValueProvided = status.New(codes.InvalidArgument, "etcdserver: value is provided").Err()
+	ErrGRPCLeaseProvided = status.New(codes.InvalidArgument, "etcdserver: lease is provided").Err()
+	ErrGRPCTooManyOps    = status.New(codes.InvalidArgument, "etcdserver: too many operations in txn request").Err()
+	ErrGRPCDuplicateKey  = status.New(codes.InvalidArgument, "etcdserver: duplicate key given in txn request").Err()
+	ErrGRPCCompacted     = status.New(codes.OutOfRange, "etcdserver: mvcc: required revision has been compacted").Err()
+	ErrGRPCFutureRev     = status.New(codes.OutOfRange, "etcdserver: mvcc: required revision is a future revision").Err()
+	ErrGRPCNoSpace       = status.New(codes.ResourceExhausted, "etcdserver: mvcc: database space exceeded").Err()
 
-	ErrGRPCLeaseNotFound    = grpc.Errorf(codes.NotFound, "etcdserver: requested lease not found")
-	ErrGRPCLeaseExist       = grpc.Errorf(codes.FailedPrecondition, "etcdserver: lease already exists")
-	ErrGRPCLeaseTTLTooLarge = grpc.Errorf(codes.OutOfRange, "etcdserver: too large lease TTL")
+	ErrGRPCLeaseNotFound    = status.New(codes.NotFound, "etcdserver: requested lease not found").Err()
+	ErrGRPCLeaseExist       = status.New(codes.FailedPrecondition, "etcdserver: lease already exists").Err()
+	ErrGRPCLeaseTTLTooLarge = status.New(codes.OutOfRange, "etcdserver: too large lease TTL").Err()
 
-	ErrGRPCMemberExist            = grpc.Errorf(codes.FailedPrecondition, "etcdserver: member ID already exist")
-	ErrGRPCPeerURLExist           = grpc.Errorf(codes.FailedPrecondition, "etcdserver: Peer URLs already exists")
-	ErrGRPCMemberNotEnoughStarted = grpc.Errorf(codes.FailedPrecondition, "etcdserver: re-configuration failed due to not enough started members")
-	ErrGRPCMemberBadURLs          = grpc.Errorf(codes.InvalidArgument, "etcdserver: given member URLs are invalid")
-	ErrGRPCMemberNotFound         = grpc.Errorf(codes.NotFound, "etcdserver: member not found")
+	ErrGRPCMemberExist            = status.New(codes.FailedPrecondition, "etcdserver: member ID already exist").Err()
+	ErrGRPCPeerURLExist           = status.New(codes.FailedPrecondition, "etcdserver: Peer URLs already exists").Err()
+	ErrGRPCMemberNotEnoughStarted = status.New(codes.FailedPrecondition, "etcdserver: re-configuration failed due to not enough started members").Err()
+	ErrGRPCMemberBadURLs          = status.New(codes.InvalidArgument, "etcdserver: given member URLs are invalid").Err()
+	ErrGRPCMemberNotFound         = status.New(codes.NotFound, "etcdserver: member not found").Err()
 
-	ErrGRPCRequestTooLarge        = grpc.Errorf(codes.InvalidArgument, "etcdserver: request is too large")
-	ErrGRPCRequestTooManyRequests = grpc.Errorf(codes.ResourceExhausted, "etcdserver: too many requests")
+	ErrGRPCRequestTooLarge        = status.New(codes.InvalidArgument, "etcdserver: request is too large").Err()
+	ErrGRPCRequestTooManyRequests = status.New(codes.ResourceExhausted, "etcdserver: too many requests").Err()
 
-	ErrGRPCRootUserNotExist     = grpc.Errorf(codes.FailedPrecondition, "etcdserver: root user does not exist")
-	ErrGRPCRootRoleNotExist     = grpc.Errorf(codes.FailedPrecondition, "etcdserver: root user does not have root role")
-	ErrGRPCUserAlreadyExist     = grpc.Errorf(codes.FailedPrecondition, "etcdserver: user name already exists")
-	ErrGRPCUserEmpty            = grpc.Errorf(codes.InvalidArgument, "etcdserver: user name is empty")
-	ErrGRPCUserNotFound         = grpc.Errorf(codes.FailedPrecondition, "etcdserver: user name not found")
-	ErrGRPCRoleAlreadyExist     = grpc.Errorf(codes.FailedPrecondition, "etcdserver: role name already exists")
-	ErrGRPCRoleNotFound         = grpc.Errorf(codes.FailedPrecondition, "etcdserver: role name not found")
-	ErrGRPCAuthFailed           = grpc.Errorf(codes.InvalidArgument, "etcdserver: authentication failed, invalid user ID or password")
-	ErrGRPCPermissionDenied     = grpc.Errorf(codes.PermissionDenied, "etcdserver: permission denied")
-	ErrGRPCRoleNotGranted       = grpc.Errorf(codes.FailedPrecondition, "etcdserver: role is not granted to the user")
-	ErrGRPCPermissionNotGranted = grpc.Errorf(codes.FailedPrecondition, "etcdserver: permission is not granted to the role")
-	ErrGRPCAuthNotEnabled       = grpc.Errorf(codes.FailedPrecondition, "etcdserver: authentication is not enabled")
-	ErrGRPCInvalidAuthToken     = grpc.Errorf(codes.Unauthenticated, "etcdserver: invalid auth token")
-	ErrGRPCInvalidAuthMgmt      = grpc.Errorf(codes.InvalidArgument, "etcdserver: invalid auth management")
+	ErrGRPCRootUserNotExist     = status.New(codes.FailedPrecondition, "etcdserver: root user does not exist").Err()
+	ErrGRPCRootRoleNotExist     = status.New(codes.FailedPrecondition, "etcdserver: root user does not have root role").Err()
+	ErrGRPCUserAlreadyExist     = status.New(codes.FailedPrecondition, "etcdserver: user name already exists").Err()
+	ErrGRPCUserEmpty            = status.New(codes.InvalidArgument, "etcdserver: user name is empty").Err()
+	ErrGRPCUserNotFound         = status.New(codes.FailedPrecondition, "etcdserver: user name not found").Err()
+	ErrGRPCRoleAlreadyExist     = status.New(codes.FailedPrecondition, "etcdserver: role name already exists").Err()
+	ErrGRPCRoleNotFound         = status.New(codes.FailedPrecondition, "etcdserver: role name not found").Err()
+	ErrGRPCAuthFailed           = status.New(codes.InvalidArgument, "etcdserver: authentication failed, invalid user ID or password").Err()
+	ErrGRPCPermissionDenied     = status.New(codes.PermissionDenied, "etcdserver: permission denied").Err()
+	ErrGRPCRoleNotGranted       = status.New(codes.FailedPrecondition, "etcdserver: role is not granted to the user").Err()
+	ErrGRPCPermissionNotGranted = status.New(codes.FailedPrecondition, "etcdserver: permission is not granted to the role").Err()
+	ErrGRPCAuthNotEnabled       = status.New(codes.FailedPrecondition, "etcdserver: authentication is not enabled").Err()
+	ErrGRPCInvalidAuthToken     = status.New(codes.Unauthenticated, "etcdserver: invalid auth token").Err()
+	ErrGRPCInvalidAuthMgmt      = status.New(codes.InvalidArgument, "etcdserver: invalid auth management").Err()
 
-	ErrGRPCNoLeader                   = grpc.Errorf(codes.Unavailable, "etcdserver: no leader")
-	ErrGRPCNotCapable                 = grpc.Errorf(codes.Unavailable, "etcdserver: not capable")
-	ErrGRPCStopped                    = grpc.Errorf(codes.Unavailable, "etcdserver: server stopped")
-	ErrGRPCTimeout                    = grpc.Errorf(codes.Unavailable, "etcdserver: request timed out")
-	ErrGRPCTimeoutDueToLeaderFail     = grpc.Errorf(codes.Unavailable, "etcdserver: request timed out, possibly due to previous leader failure")
-	ErrGRPCTimeoutDueToConnectionLost = grpc.Errorf(codes.Unavailable, "etcdserver: request timed out, possibly due to connection lost")
-	ErrGRPCUnhealthy                  = grpc.Errorf(codes.Unavailable, "etcdserver: unhealthy cluster")
+	ErrGRPCNoLeader                   = status.New(codes.Unavailable, "etcdserver: no leader").Err()
+	ErrGRPCNotLeader                  = status.New(codes.FailedPrecondition, "etcdserver: not leader").Err()
+	ErrGRPCNotCapable                 = status.New(codes.Unavailable, "etcdserver: not capable").Err()
+	ErrGRPCStopped                    = status.New(codes.Unavailable, "etcdserver: server stopped").Err()
+	ErrGRPCTimeout                    = status.New(codes.Unavailable, "etcdserver: request timed out").Err()
+	ErrGRPCTimeoutDueToLeaderFail     = status.New(codes.Unavailable, "etcdserver: request timed out, possibly due to previous leader failure").Err()
+	ErrGRPCTimeoutDueToConnectionLost = status.New(codes.Unavailable, "etcdserver: request timed out, possibly due to connection lost").Err()
+	ErrGRPCUnhealthy                  = status.New(codes.Unavailable, "etcdserver: unhealthy cluster").Err()
+	ErrGRPCCorrupt                    = status.New(codes.DataLoss, "etcdserver: corrupt cluster").Err()
 
 	errStringToError = map[string]error{
-		grpc.ErrorDesc(ErrGRPCEmptyKey):      ErrGRPCEmptyKey,
-		grpc.ErrorDesc(ErrGRPCKeyNotFound):   ErrGRPCKeyNotFound,
-		grpc.ErrorDesc(ErrGRPCValueProvided): ErrGRPCValueProvided,
-		grpc.ErrorDesc(ErrGRPCLeaseProvided): ErrGRPCLeaseProvided,
+		ErrorDesc(ErrGRPCEmptyKey):      ErrGRPCEmptyKey,
+		ErrorDesc(ErrGRPCKeyNotFound):   ErrGRPCKeyNotFound,
+		ErrorDesc(ErrGRPCValueProvided): ErrGRPCValueProvided,
+		ErrorDesc(ErrGRPCLeaseProvided): ErrGRPCLeaseProvided,
 
-		grpc.ErrorDesc(ErrGRPCTooManyOps):   ErrGRPCTooManyOps,
-		grpc.ErrorDesc(ErrGRPCDuplicateKey): ErrGRPCDuplicateKey,
-		grpc.ErrorDesc(ErrGRPCCompacted):    ErrGRPCCompacted,
-		grpc.ErrorDesc(ErrGRPCFutureRev):    ErrGRPCFutureRev,
-		grpc.ErrorDesc(ErrGRPCNoSpace):      ErrGRPCNoSpace,
+		ErrorDesc(ErrGRPCTooManyOps):   ErrGRPCTooManyOps,
+		ErrorDesc(ErrGRPCDuplicateKey): ErrGRPCDuplicateKey,
+		ErrorDesc(ErrGRPCCompacted):    ErrGRPCCompacted,
+		ErrorDesc(ErrGRPCFutureRev):    ErrGRPCFutureRev,
+		ErrorDesc(ErrGRPCNoSpace):      ErrGRPCNoSpace,
 
-		grpc.ErrorDesc(ErrGRPCLeaseNotFound):    ErrGRPCLeaseNotFound,
-		grpc.ErrorDesc(ErrGRPCLeaseExist):       ErrGRPCLeaseExist,
-		grpc.ErrorDesc(ErrGRPCLeaseTTLTooLarge): ErrGRPCLeaseTTLTooLarge,
+		ErrorDesc(ErrGRPCLeaseNotFound):    ErrGRPCLeaseNotFound,
+		ErrorDesc(ErrGRPCLeaseExist):       ErrGRPCLeaseExist,
+		ErrorDesc(ErrGRPCLeaseTTLTooLarge): ErrGRPCLeaseTTLTooLarge,
 
-		grpc.ErrorDesc(ErrGRPCMemberExist):            ErrGRPCMemberExist,
-		grpc.ErrorDesc(ErrGRPCPeerURLExist):           ErrGRPCPeerURLExist,
-		grpc.ErrorDesc(ErrGRPCMemberNotEnoughStarted): ErrGRPCMemberNotEnoughStarted,
-		grpc.ErrorDesc(ErrGRPCMemberBadURLs):          ErrGRPCMemberBadURLs,
-		grpc.ErrorDesc(ErrGRPCMemberNotFound):         ErrGRPCMemberNotFound,
+		ErrorDesc(ErrGRPCMemberExist):            ErrGRPCMemberExist,
+		ErrorDesc(ErrGRPCPeerURLExist):           ErrGRPCPeerURLExist,
+		ErrorDesc(ErrGRPCMemberNotEnoughStarted): ErrGRPCMemberNotEnoughStarted,
+		ErrorDesc(ErrGRPCMemberBadURLs):          ErrGRPCMemberBadURLs,
+		ErrorDesc(ErrGRPCMemberNotFound):         ErrGRPCMemberNotFound,
 
-		grpc.ErrorDesc(ErrGRPCRequestTooLarge):        ErrGRPCRequestTooLarge,
-		grpc.ErrorDesc(ErrGRPCRequestTooManyRequests): ErrGRPCRequestTooManyRequests,
+		ErrorDesc(ErrGRPCRequestTooLarge):        ErrGRPCRequestTooLarge,
+		ErrorDesc(ErrGRPCRequestTooManyRequests): ErrGRPCRequestTooManyRequests,
 
-		grpc.ErrorDesc(ErrGRPCRootUserNotExist):     ErrGRPCRootUserNotExist,
-		grpc.ErrorDesc(ErrGRPCRootRoleNotExist):     ErrGRPCRootRoleNotExist,
-		grpc.ErrorDesc(ErrGRPCUserAlreadyExist):     ErrGRPCUserAlreadyExist,
-		grpc.ErrorDesc(ErrGRPCUserEmpty):            ErrGRPCUserEmpty,
-		grpc.ErrorDesc(ErrGRPCUserNotFound):         ErrGRPCUserNotFound,
-		grpc.ErrorDesc(ErrGRPCRoleAlreadyExist):     ErrGRPCRoleAlreadyExist,
-		grpc.ErrorDesc(ErrGRPCRoleNotFound):         ErrGRPCRoleNotFound,
-		grpc.ErrorDesc(ErrGRPCAuthFailed):           ErrGRPCAuthFailed,
-		grpc.ErrorDesc(ErrGRPCPermissionDenied):     ErrGRPCPermissionDenied,
-		grpc.ErrorDesc(ErrGRPCRoleNotGranted):       ErrGRPCRoleNotGranted,
-		grpc.ErrorDesc(ErrGRPCPermissionNotGranted): ErrGRPCPermissionNotGranted,
-		grpc.ErrorDesc(ErrGRPCAuthNotEnabled):       ErrGRPCAuthNotEnabled,
-		grpc.ErrorDesc(ErrGRPCInvalidAuthToken):     ErrGRPCInvalidAuthToken,
-		grpc.ErrorDesc(ErrGRPCInvalidAuthMgmt):      ErrGRPCInvalidAuthMgmt,
+		ErrorDesc(ErrGRPCRootUserNotExist):     ErrGRPCRootUserNotExist,
+		ErrorDesc(ErrGRPCRootRoleNotExist):     ErrGRPCRootRoleNotExist,
+		ErrorDesc(ErrGRPCUserAlreadyExist):     ErrGRPCUserAlreadyExist,
+		ErrorDesc(ErrGRPCUserEmpty):            ErrGRPCUserEmpty,
+		ErrorDesc(ErrGRPCUserNotFound):         ErrGRPCUserNotFound,
+		ErrorDesc(ErrGRPCRoleAlreadyExist):     ErrGRPCRoleAlreadyExist,
+		ErrorDesc(ErrGRPCRoleNotFound):         ErrGRPCRoleNotFound,
+		ErrorDesc(ErrGRPCAuthFailed):           ErrGRPCAuthFailed,
+		ErrorDesc(ErrGRPCPermissionDenied):     ErrGRPCPermissionDenied,
+		ErrorDesc(ErrGRPCRoleNotGranted):       ErrGRPCRoleNotGranted,
+		ErrorDesc(ErrGRPCPermissionNotGranted): ErrGRPCPermissionNotGranted,
+		ErrorDesc(ErrGRPCAuthNotEnabled):       ErrGRPCAuthNotEnabled,
+		ErrorDesc(ErrGRPCInvalidAuthToken):     ErrGRPCInvalidAuthToken,
+		ErrorDesc(ErrGRPCInvalidAuthMgmt):      ErrGRPCInvalidAuthMgmt,
 
-		grpc.ErrorDesc(ErrGRPCNoLeader):                   ErrGRPCNoLeader,
-		grpc.ErrorDesc(ErrGRPCNotCapable):                 ErrGRPCNotCapable,
-		grpc.ErrorDesc(ErrGRPCStopped):                    ErrGRPCStopped,
-		grpc.ErrorDesc(ErrGRPCTimeout):                    ErrGRPCTimeout,
-		grpc.ErrorDesc(ErrGRPCTimeoutDueToLeaderFail):     ErrGRPCTimeoutDueToLeaderFail,
-		grpc.ErrorDesc(ErrGRPCTimeoutDueToConnectionLost): ErrGRPCTimeoutDueToConnectionLost,
-		grpc.ErrorDesc(ErrGRPCUnhealthy):                  ErrGRPCUnhealthy,
+		ErrorDesc(ErrGRPCNoLeader):                   ErrGRPCNoLeader,
+		ErrorDesc(ErrGRPCNotLeader):                  ErrGRPCNotLeader,
+		ErrorDesc(ErrGRPCNotCapable):                 ErrGRPCNotCapable,
+		ErrorDesc(ErrGRPCStopped):                    ErrGRPCStopped,
+		ErrorDesc(ErrGRPCTimeout):                    ErrGRPCTimeout,
+		ErrorDesc(ErrGRPCTimeoutDueToLeaderFail):     ErrGRPCTimeoutDueToLeaderFail,
+		ErrorDesc(ErrGRPCTimeoutDueToConnectionLost): ErrGRPCTimeoutDueToConnectionLost,
+		ErrorDesc(ErrGRPCUnhealthy):                  ErrGRPCUnhealthy,
+		ErrorDesc(ErrGRPCCorrupt):                    ErrGRPCCorrupt,
 	}
+)
 
-	// client-side error
+// client-side error
+var (
 	ErrEmptyKey      = Error(ErrGRPCEmptyKey)
 	ErrKeyNotFound   = Error(ErrGRPCKeyNotFound)
 	ErrValueProvided = Error(ErrGRPCValueProvided)
@@ -157,12 +162,14 @@ var (
 	ErrInvalidAuthMgmt      = Error(ErrGRPCInvalidAuthMgmt)
 
 	ErrNoLeader                   = Error(ErrGRPCNoLeader)
+	ErrNotLeader                  = Error(ErrGRPCNotLeader)
 	ErrNotCapable                 = Error(ErrGRPCNotCapable)
 	ErrStopped                    = Error(ErrGRPCStopped)
 	ErrTimeout                    = Error(ErrGRPCTimeout)
 	ErrTimeoutDueToLeaderFail     = Error(ErrGRPCTimeoutDueToLeaderFail)
 	ErrTimeoutDueToConnectionLost = Error(ErrGRPCTimeoutDueToConnectionLost)
 	ErrUnhealthy                  = Error(ErrGRPCUnhealthy)
+	ErrCorrupt                    = Error(ErrGRPCCorrupt)
 )
 
 // EtcdError defines gRPC server errors.
@@ -186,11 +193,18 @@ func Error(err error) error {
 	if err == nil {
 		return nil
 	}
-	verr, ok := errStringToError[grpc.ErrorDesc(err)]
+	verr, ok := errStringToError[ErrorDesc(err)]
 	if !ok { // not gRPC error
 		return err
 	}
-	return EtcdError{code: grpc.Code(verr), desc: grpc.ErrorDesc(verr)}
+	ev, ok := status.FromError(verr)
+	var desc string
+	if ok {
+		desc = ev.Message()
+	} else {
+		desc = verr.Error()
+	}
+	return EtcdError{code: ev.Code(), desc: desc}
 }
 
 func ErrorDesc(err error) string {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/util.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/util.go
index 3df837a33c0..799c1197d8d 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/util.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/util.go
@@ -15,6 +15,7 @@
 package v3rpc
 
 import (
+	"context"
 	"strings"
 
 	"github.com/coreos/etcd/auth"
@@ -24,88 +25,63 @@ import (
 	"github.com/coreos/etcd/lease"
 	"github.com/coreos/etcd/mvcc"
 
-	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
+var toGRPCErrorMap = map[error]error{
+	membership.ErrIDRemoved:               rpctypes.ErrGRPCMemberNotFound,
+	membership.ErrIDNotFound:              rpctypes.ErrGRPCMemberNotFound,
+	membership.ErrIDExists:                rpctypes.ErrGRPCMemberExist,
+	membership.ErrPeerURLexists:           rpctypes.ErrGRPCPeerURLExist,
+	etcdserver.ErrNotEnoughStartedMembers: rpctypes.ErrMemberNotEnoughStarted,
+
+	mvcc.ErrCompacted:             rpctypes.ErrGRPCCompacted,
+	mvcc.ErrFutureRev:             rpctypes.ErrGRPCFutureRev,
+	etcdserver.ErrRequestTooLarge: rpctypes.ErrGRPCRequestTooLarge,
+	etcdserver.ErrNoSpace:         rpctypes.ErrGRPCNoSpace,
+	etcdserver.ErrTooManyRequests: rpctypes.ErrTooManyRequests,
+
+	etcdserver.ErrNoLeader:                   rpctypes.ErrGRPCNoLeader,
+	etcdserver.ErrNotLeader:                  rpctypes.ErrGRPCNotLeader,
+	etcdserver.ErrStopped:                    rpctypes.ErrGRPCStopped,
+	etcdserver.ErrTimeout:                    rpctypes.ErrGRPCTimeout,
+	etcdserver.ErrTimeoutDueToLeaderFail:     rpctypes.ErrGRPCTimeoutDueToLeaderFail,
+	etcdserver.ErrTimeoutDueToConnectionLost: rpctypes.ErrGRPCTimeoutDueToConnectionLost,
+	etcdserver.ErrUnhealthy:                  rpctypes.ErrGRPCUnhealthy,
+	etcdserver.ErrKeyNotFound:                rpctypes.ErrGRPCKeyNotFound,
+	etcdserver.ErrCorrupt:                    rpctypes.ErrGRPCCorrupt,
+
+	lease.ErrLeaseNotFound:    rpctypes.ErrGRPCLeaseNotFound,
+	lease.ErrLeaseExists:      rpctypes.ErrGRPCLeaseExist,
+	lease.ErrLeaseTTLTooLarge: rpctypes.ErrGRPCLeaseTTLTooLarge,
+
+	auth.ErrRootUserNotExist:     rpctypes.ErrGRPCRootUserNotExist,
+	auth.ErrRootRoleNotExist:     rpctypes.ErrGRPCRootRoleNotExist,
+	auth.ErrUserAlreadyExist:     rpctypes.ErrGRPCUserAlreadyExist,
+	auth.ErrUserEmpty:            rpctypes.ErrGRPCUserEmpty,
+	auth.ErrUserNotFound:         rpctypes.ErrGRPCUserNotFound,
+	auth.ErrRoleAlreadyExist:     rpctypes.ErrGRPCRoleAlreadyExist,
+	auth.ErrRoleNotFound:         rpctypes.ErrGRPCRoleNotFound,
+	auth.ErrAuthFailed:           rpctypes.ErrGRPCAuthFailed,
+	auth.ErrPermissionDenied:     rpctypes.ErrGRPCPermissionDenied,
+	auth.ErrRoleNotGranted:       rpctypes.ErrGRPCRoleNotGranted,
+	auth.ErrPermissionNotGranted: rpctypes.ErrGRPCPermissionNotGranted,
+	auth.ErrAuthNotEnabled:       rpctypes.ErrGRPCAuthNotEnabled,
+	auth.ErrInvalidAuthToken:     rpctypes.ErrGRPCInvalidAuthToken,
+	auth.ErrInvalidAuthMgmt:      rpctypes.ErrGRPCInvalidAuthMgmt,
+}
+
 func togRPCError(err error) error {
-	switch err {
-	case membership.ErrIDRemoved:
-		return rpctypes.ErrGRPCMemberNotFound
-	case membership.ErrIDNotFound:
-		return rpctypes.ErrGRPCMemberNotFound
-	case membership.ErrIDExists:
-		return rpctypes.ErrGRPCMemberExist
-	case membership.ErrPeerURLexists:
-		return rpctypes.ErrGRPCPeerURLExist
-	case etcdserver.ErrNotEnoughStartedMembers:
-		return rpctypes.ErrMemberNotEnoughStarted
-
-	case mvcc.ErrCompacted:
-		return rpctypes.ErrGRPCCompacted
-	case mvcc.ErrFutureRev:
-		return rpctypes.ErrGRPCFutureRev
-	case etcdserver.ErrRequestTooLarge:
-		return rpctypes.ErrGRPCRequestTooLarge
-	case etcdserver.ErrNoSpace:
-		return rpctypes.ErrGRPCNoSpace
-	case etcdserver.ErrTooManyRequests:
-		return rpctypes.ErrTooManyRequests
-
-	case etcdserver.ErrNoLeader:
-		return rpctypes.ErrGRPCNoLeader
-	case etcdserver.ErrStopped:
-		return rpctypes.ErrGRPCStopped
-	case etcdserver.ErrTimeout:
-		return rpctypes.ErrGRPCTimeout
-	case etcdserver.ErrTimeoutDueToLeaderFail:
-		return rpctypes.ErrGRPCTimeoutDueToLeaderFail
-	case etcdserver.ErrTimeoutDueToConnectionLost:
-		return rpctypes.ErrGRPCTimeoutDueToConnectionLost
-	case etcdserver.ErrUnhealthy:
-		return rpctypes.ErrGRPCUnhealthy
-	case etcdserver.ErrKeyNotFound:
-		return rpctypes.ErrGRPCKeyNotFound
-
-	case lease.ErrLeaseNotFound:
-		return rpctypes.ErrGRPCLeaseNotFound
-	case lease.ErrLeaseExists:
-		return rpctypes.ErrGRPCLeaseExist
-	case lease.ErrLeaseTTLTooLarge:
-		return rpctypes.ErrGRPCLeaseTTLTooLarge
-
-	case auth.ErrRootUserNotExist:
-		return rpctypes.ErrGRPCRootUserNotExist
-	case auth.ErrRootRoleNotExist:
-		return rpctypes.ErrGRPCRootRoleNotExist
-	case auth.ErrUserAlreadyExist:
-		return rpctypes.ErrGRPCUserAlreadyExist
-	case auth.ErrUserEmpty:
-		return rpctypes.ErrGRPCUserEmpty
-	case auth.ErrUserNotFound:
-		return rpctypes.ErrGRPCUserNotFound
-	case auth.ErrRoleAlreadyExist:
-		return rpctypes.ErrGRPCRoleAlreadyExist
-	case auth.ErrRoleNotFound:
-		return rpctypes.ErrGRPCRoleNotFound
-	case auth.ErrAuthFailed:
-		return rpctypes.ErrGRPCAuthFailed
-	case auth.ErrPermissionDenied:
-		return rpctypes.ErrGRPCPermissionDenied
-	case auth.ErrRoleNotGranted:
-		return rpctypes.ErrGRPCRoleNotGranted
-	case auth.ErrPermissionNotGranted:
-		return rpctypes.ErrGRPCPermissionNotGranted
-	case auth.ErrAuthNotEnabled:
-		return rpctypes.ErrGRPCAuthNotEnabled
-	case auth.ErrInvalidAuthToken:
-		return rpctypes.ErrGRPCInvalidAuthToken
-	case auth.ErrInvalidAuthMgmt:
-		return rpctypes.ErrGRPCInvalidAuthMgmt
-	default:
-		return grpc.Errorf(codes.Unknown, err.Error())
+	// let gRPC server convert to codes.Canceled, codes.DeadlineExceeded
+	if err == context.Canceled || err == context.DeadlineExceeded {
+		return err
 	}
+	grpcErr, ok := toGRPCErrorMap[err]
+	if !ok {
+		return status.Error(codes.Unknown, err.Error())
+	}
+	return grpcErr
 }
 
 func isClientCtxErr(ctxErr error, err error) bool {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/watch.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/watch.go
index 301ffbaf47f..dd4f329515d 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/watch.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/watch.go
@@ -15,12 +15,11 @@
 package v3rpc
 
 import (
+	"context"
 	"io"
 	"sync"
 	"time"
 
-	"golang.org/x/net/context"
-
 	"github.com/coreos/etcd/auth"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
@@ -326,11 +325,13 @@ func (sws *serverWatchStream) sendLoop() {
 				}
 			}
 
+			canceled := wresp.CompactRevision != 0
 			wr := &pb.WatchResponse{
 				Header:          sws.newResponseHeader(wresp.Revision),
 				WatchId:         int64(wresp.WatchID),
 				Events:          events,
 				CompactRevision: wresp.CompactRevision,
+				Canceled:        canceled,
 			}
 
 			if _, hasId := ids[wresp.WatchID]; !hasId {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/apply.go b/vendor/github.com/coreos/etcd/etcdserver/apply.go
index 3971fdf608f..93e78e390c8 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/apply.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/apply.go
@@ -16,16 +16,18 @@ package etcdserver
 
 import (
 	"bytes"
+	"context"
 	"sort"
 	"time"
 
+	"github.com/coreos/etcd/auth"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/lease"
 	"github.com/coreos/etcd/mvcc"
 	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/types"
+
 	"github.com/gogo/protobuf/proto"
-	"golang.org/x/net/context"
 )
 
 const (
@@ -76,14 +78,31 @@ type applierV3 interface {
 	RoleList(ua *pb.AuthRoleListRequest) (*pb.AuthRoleListResponse, error)
 }
 
+type checkReqFunc func(mvcc.ReadView, *pb.RequestOp) error
+
 type applierV3backend struct {
 	s *EtcdServer
+
+	checkPut   checkReqFunc
+	checkRange checkReqFunc
+}
+
+func (s *EtcdServer) newApplierV3Backend() applierV3 {
+	base := &applierV3backend{s: s}
+	base.checkPut = func(rv mvcc.ReadView, req *pb.RequestOp) error {
+		return base.checkRequestPut(rv, req)
+	}
+	base.checkRange = func(rv mvcc.ReadView, req *pb.RequestOp) error {
+		return base.checkRequestRange(rv, req)
+	}
+	return base
 }
 
 func (s *EtcdServer) newApplierV3() applierV3 {
 	return newAuthApplierV3(
 		s.AuthStore(),
-		newQuotaApplierV3(s, &applierV3backend{s}),
+		newQuotaApplierV3(s, s.newApplierV3Backend()),
+		s.lessor,
 	)
 }
 
@@ -196,29 +215,27 @@ func (a *applierV3backend) Put(txn mvcc.TxnWrite, p *pb.PutRequest) (resp *pb.Pu
 func (a *applierV3backend) DeleteRange(txn mvcc.TxnWrite, dr *pb.DeleteRangeRequest) (*pb.DeleteRangeResponse, error) {
 	resp := &pb.DeleteRangeResponse{}
 	resp.Header = &pb.ResponseHeader{}
+	end := mkGteRange(dr.RangeEnd)
 
 	if txn == nil {
 		txn = a.s.kv.Write()
 		defer txn.End()
 	}
 
-	if isGteRange(dr.RangeEnd) {
-		dr.RangeEnd = []byte{}
-	}
-
 	if dr.PrevKv {
-		rr, err := txn.Range(dr.Key, dr.RangeEnd, mvcc.RangeOptions{})
+		rr, err := txn.Range(dr.Key, end, mvcc.RangeOptions{})
 		if err != nil {
 			return nil, err
 		}
 		if rr != nil {
+			resp.PrevKvs = make([]*mvccpb.KeyValue, len(rr.KVs))
 			for i := range rr.KVs {
-				resp.PrevKvs = append(resp.PrevKvs, &rr.KVs[i])
+				resp.PrevKvs[i] = &rr.KVs[i]
 			}
 		}
 	}
 
-	resp.Deleted, resp.Header.Revision = txn.DeleteRange(dr.Key, dr.RangeEnd)
+	resp.Deleted, resp.Header.Revision = txn.DeleteRange(dr.Key, end)
 	return resp, nil
 }
 
@@ -231,10 +248,6 @@ func (a *applierV3backend) Range(txn mvcc.TxnRead, r *pb.RangeRequest) (*pb.Rang
 		defer txn.End()
 	}
 
-	if isGteRange(r.RangeEnd) {
-		r.RangeEnd = []byte{}
-	}
-
 	limit := r.Limit
 	if r.SortOrder != pb.RangeRequest_NONE ||
 		r.MinModRevision != 0 || r.MaxModRevision != 0 ||
@@ -253,7 +266,7 @@ func (a *applierV3backend) Range(txn mvcc.TxnRead, r *pb.RangeRequest) (*pb.Rang
 		Count: r.CountOnly,
 	}
 
-	rr, err := txn.Range(r.Key, r.RangeEnd, ro)
+	rr, err := txn.Range(r.Key, mkGteRange(r.RangeEnd), ro)
 	if err != nil {
 		return nil, err
 	}
@@ -311,11 +324,12 @@ func (a *applierV3backend) Range(txn mvcc.TxnRead, r *pb.RangeRequest) (*pb.Rang
 
 	resp.Header.Revision = rr.Rev
 	resp.Count = int64(rr.Count)
+	resp.Kvs = make([]*mvccpb.KeyValue, len(rr.KVs))
 	for i := range rr.KVs {
 		if r.KeysOnly {
 			rr.KVs[i].Value = nil
 		}
-		resp.Kvs = append(resp.Kvs, &rr.KVs[i])
+		resp.Kvs[i] = &rr.KVs[i]
 	}
 	return resp, nil
 }
@@ -324,24 +338,19 @@ func (a *applierV3backend) Txn(rt *pb.TxnRequest) (*pb.TxnResponse, error) {
 	isWrite := !isTxnReadonly(rt)
 	txn := mvcc.NewReadOnlyTxnWrite(a.s.KV().Read())
 
-	reqs, ok := a.compareToOps(txn, rt)
+	txnPath := compareToPath(txn, rt)
 	if isWrite {
-		if err := a.checkRequestPut(txn, reqs); err != nil {
+		if _, err := checkRequests(txn, rt, txnPath, a.checkPut); err != nil {
 			txn.End()
 			return nil, err
 		}
 	}
-	if err := checkRequestRange(txn, reqs); err != nil {
+	if _, err := checkRequests(txn, rt, txnPath, a.checkRange); err != nil {
 		txn.End()
 		return nil, err
 	}
 
-	resps := make([]*pb.ResponseOp, len(reqs))
-	txnResp := &pb.TxnResponse{
-		Responses: resps,
-		Succeeded: ok,
-		Header:    &pb.ResponseHeader{},
-	}
+	txnResp, _ := newTxnResp(rt, txnPath)
 
 	// When executing mutable txn ops, etcd must hold the txn lock so
 	// readers do not see any intermediate results. Since writes are
@@ -351,9 +360,7 @@ func (a *applierV3backend) Txn(rt *pb.TxnRequest) (*pb.TxnResponse, error) {
 		txn.End()
 		txn = a.s.KV().Write()
 	}
-	for i := range reqs {
-		resps[i] = a.applyUnion(txn, reqs[i])
-	}
+	a.applyTxn(txn, rt, txnPath, txnResp)
 	rev := txn.Rev()
 	if len(txn.Changes()) != 0 {
 		rev++
@@ -364,62 +371,121 @@ func (a *applierV3backend) Txn(rt *pb.TxnRequest) (*pb.TxnResponse, error) {
 	return txnResp, nil
 }
 
-func (a *applierV3backend) compareToOps(rv mvcc.ReadView, rt *pb.TxnRequest) ([]*pb.RequestOp, bool) {
-	for _, c := range rt.Compare {
-		if !applyCompare(rv, c) {
-			return rt.Failure, false
+// newTxnResp allocates a txn response for a txn request given a path.
+func newTxnResp(rt *pb.TxnRequest, txnPath []bool) (txnResp *pb.TxnResponse, txnCount int) {
+	reqs := rt.Success
+	if !txnPath[0] {
+		reqs = rt.Failure
+	}
+	resps := make([]*pb.ResponseOp, len(reqs))
+	txnResp = &pb.TxnResponse{
+		Responses: resps,
+		Succeeded: txnPath[0],
+		Header:    &pb.ResponseHeader{},
+	}
+	for i, req := range reqs {
+		switch tv := req.Request.(type) {
+		case *pb.RequestOp_RequestRange:
+			resps[i] = &pb.ResponseOp{Response: &pb.ResponseOp_ResponseRange{}}
+		case *pb.RequestOp_RequestPut:
+			resps[i] = &pb.ResponseOp{Response: &pb.ResponseOp_ResponsePut{}}
+		case *pb.RequestOp_RequestDeleteRange:
+			resps[i] = &pb.ResponseOp{Response: &pb.ResponseOp_ResponseDeleteRange{}}
+		case *pb.RequestOp_RequestTxn:
+			resp, txns := newTxnResp(tv.RequestTxn, txnPath[1:])
+			resps[i] = &pb.ResponseOp{Response: &pb.ResponseOp_ResponseTxn{ResponseTxn: resp}}
+			txnPath = txnPath[1+txns:]
+			txnCount += txns + 1
+		default:
 		}
 	}
-	return rt.Success, true
+	return txnResp, txnCount
+}
+
+func compareToPath(rv mvcc.ReadView, rt *pb.TxnRequest) []bool {
+	txnPath := make([]bool, 1)
+	ops := rt.Success
+	if txnPath[0] = applyCompares(rv, rt.Compare); !txnPath[0] {
+		ops = rt.Failure
+	}
+	for _, op := range ops {
+		tv, ok := op.Request.(*pb.RequestOp_RequestTxn)
+		if !ok || tv.RequestTxn == nil {
+			continue
+		}
+		txnPath = append(txnPath, compareToPath(rv, tv.RequestTxn)...)
+	}
+	return txnPath
+}
+
+func applyCompares(rv mvcc.ReadView, cmps []*pb.Compare) bool {
+	for _, c := range cmps {
+		if !applyCompare(rv, c) {
+			return false
+		}
+	}
+	return true
 }
 
 // applyCompare applies the compare request.
 // If the comparison succeeds, it returns true. Otherwise, returns false.
 func applyCompare(rv mvcc.ReadView, c *pb.Compare) bool {
-	rr, err := rv.Range(c.Key, nil, mvcc.RangeOptions{})
+	// TODO: possible optimizations
+	// * chunk reads for large ranges to conserve memory
+	// * rewrite rules for common patterns:
+	//	ex. "[a, b) createrev > 0" => "limit 1 /\ kvs > 0"
+	// * caching
+	rr, err := rv.Range(c.Key, mkGteRange(c.RangeEnd), mvcc.RangeOptions{})
 	if err != nil {
 		return false
 	}
-	var ckv mvccpb.KeyValue
-	if len(rr.KVs) != 0 {
-		ckv = rr.KVs[0]
-	} else {
-		// Use the zero value of ckv normally. However...
+	if len(rr.KVs) == 0 {
 		if c.Target == pb.Compare_VALUE {
-			// Always fail if we're comparing a value on a key that doesn't exist.
-			// We can treat non-existence as the empty set explicitly, such that
-			// even a key with a value of length 0 bytes is still a real key
-			// that was written that way
+			// Always fail if comparing a value on a key/keys that doesn't exist;
+			// nil == empty string in grpc; no way to represent missing value
+			return false
+		}
+		return compareKV(c, mvccpb.KeyValue{})
+	}
+	for _, kv := range rr.KVs {
+		if !compareKV(c, kv) {
 			return false
 		}
 	}
+	return true
+}
 
-	// -1 is less, 0 is equal, 1 is greater
+func compareKV(c *pb.Compare, ckv mvccpb.KeyValue) bool {
 	var result int
+	rev := int64(0)
 	switch c.Target {
 	case pb.Compare_VALUE:
-		tv, _ := c.TargetUnion.(*pb.Compare_Value)
-		if tv != nil {
-			result = bytes.Compare(ckv.Value, tv.Value)
+		v := []byte{}
+		if tv, _ := c.TargetUnion.(*pb.Compare_Value); tv != nil {
+			v = tv.Value
 		}
+		result = bytes.Compare(ckv.Value, v)
 	case pb.Compare_CREATE:
-		tv, _ := c.TargetUnion.(*pb.Compare_CreateRevision)
-		if tv != nil {
-			result = compareInt64(ckv.CreateRevision, tv.CreateRevision)
+		if tv, _ := c.TargetUnion.(*pb.Compare_CreateRevision); tv != nil {
+			rev = tv.CreateRevision
 		}
-
+		result = compareInt64(ckv.CreateRevision, rev)
 	case pb.Compare_MOD:
-		tv, _ := c.TargetUnion.(*pb.Compare_ModRevision)
-		if tv != nil {
-			result = compareInt64(ckv.ModRevision, tv.ModRevision)
+		if tv, _ := c.TargetUnion.(*pb.Compare_ModRevision); tv != nil {
+			rev = tv.ModRevision
 		}
+		result = compareInt64(ckv.ModRevision, rev)
 	case pb.Compare_VERSION:
-		tv, _ := c.TargetUnion.(*pb.Compare_Version)
-		if tv != nil {
-			result = compareInt64(ckv.Version, tv.Version)
+		if tv, _ := c.TargetUnion.(*pb.Compare_Version); tv != nil {
+			rev = tv.Version
 		}
+		result = compareInt64(ckv.Version, rev)
+	case pb.Compare_LEASE:
+		if tv, _ := c.TargetUnion.(*pb.Compare_Lease); tv != nil {
+			rev = tv.Lease
+		}
+		result = compareInt64(ckv.Lease, rev)
 	}
-
 	switch c.Result {
 	case pb.Compare_EQUAL:
 		return result == 0
@@ -433,38 +499,42 @@ func applyCompare(rv mvcc.ReadView, c *pb.Compare) bool {
 	return true
 }
 
-func (a *applierV3backend) applyUnion(txn mvcc.TxnWrite, union *pb.RequestOp) *pb.ResponseOp {
-	switch tv := union.Request.(type) {
-	case *pb.RequestOp_RequestRange:
-		if tv.RequestRange != nil {
+func (a *applierV3backend) applyTxn(txn mvcc.TxnWrite, rt *pb.TxnRequest, txnPath []bool, tresp *pb.TxnResponse) (txns int) {
+	reqs := rt.Success
+	if !txnPath[0] {
+		reqs = rt.Failure
+	}
+	for i, req := range reqs {
+		respi := tresp.Responses[i].Response
+		switch tv := req.Request.(type) {
+		case *pb.RequestOp_RequestRange:
 			resp, err := a.Range(txn, tv.RequestRange)
 			if err != nil {
 				plog.Panicf("unexpected error during txn: %v", err)
 			}
-			return &pb.ResponseOp{Response: &pb.ResponseOp_ResponseRange{ResponseRange: resp}}
-		}
-	case *pb.RequestOp_RequestPut:
-		if tv.RequestPut != nil {
+			respi.(*pb.ResponseOp_ResponseRange).ResponseRange = resp
+		case *pb.RequestOp_RequestPut:
 			resp, err := a.Put(txn, tv.RequestPut)
 			if err != nil {
 				plog.Panicf("unexpected error during txn: %v", err)
 			}
-			return &pb.ResponseOp{Response: &pb.ResponseOp_ResponsePut{ResponsePut: resp}}
-		}
-	case *pb.RequestOp_RequestDeleteRange:
-		if tv.RequestDeleteRange != nil {
+			respi.(*pb.ResponseOp_ResponsePut).ResponsePut = resp
+		case *pb.RequestOp_RequestDeleteRange:
 			resp, err := a.DeleteRange(txn, tv.RequestDeleteRange)
 			if err != nil {
 				plog.Panicf("unexpected error during txn: %v", err)
 			}
-			return &pb.ResponseOp{Response: &pb.ResponseOp_ResponseDeleteRange{ResponseDeleteRange: resp}}
+			respi.(*pb.ResponseOp_ResponseDeleteRange).ResponseDeleteRange = resp
+		case *pb.RequestOp_RequestTxn:
+			resp := respi.(*pb.ResponseOp_ResponseTxn).ResponseTxn
+			applyTxns := a.applyTxn(txn, tv.RequestTxn, txnPath[1:], resp)
+			txns += applyTxns + 1
+			txnPath = txnPath[applyTxns+1:]
+		default:
+			// empty union
 		}
-	default:
-		// empty union
-		return nil
 	}
-	return nil
-
+	return txns
 }
 
 func (a *applierV3backend) Compaction(compaction *pb.CompactionRequest) (*pb.CompactionResponse, <-chan struct{}, error) {
@@ -514,9 +584,11 @@ func (a *applierV3backend) Alarm(ar *pb.AlarmRequest) (*pb.AlarmResponse, error)
 			break
 		}
 
+		plog.Warningf("alarm %v raised by peer %s", m.Alarm, types.ID(m.MemberID))
 		switch m.Alarm {
+		case pb.AlarmType_CORRUPT:
+			a.s.applyV3 = newApplierV3Corrupt(a)
 		case pb.AlarmType_NOSPACE:
-			plog.Warningf("alarm raised %+v", m)
 			a.s.applyV3 = newApplierV3Capped(a)
 		default:
 			plog.Errorf("unimplemented alarm activation (%+v)", m)
@@ -533,7 +605,8 @@ func (a *applierV3backend) Alarm(ar *pb.AlarmRequest) (*pb.AlarmResponse, error)
 		}
 
 		switch m.Alarm {
-		case pb.AlarmType_NOSPACE:
+		case pb.AlarmType_NOSPACE, pb.AlarmType_CORRUPT:
+			// TODO: check kv hash before deactivating CORRUPT?
 			plog.Infof("alarm disarmed %+v", ar)
 			a.s.applyV3 = a.s.newApplierV3()
 		default:
@@ -583,7 +656,7 @@ func (a *applierV3backend) AuthDisable() (*pb.AuthDisableResponse, error) {
 }
 
 func (a *applierV3backend) Authenticate(r *pb.InternalAuthenticateRequest) (*pb.AuthenticateResponse, error) {
-	ctx := context.WithValue(context.WithValue(a.s.ctx, "index", a.s.consistIndex.ConsistentIndex()), "simpleToken", r.SimpleToken)
+	ctx := context.WithValue(context.WithValue(a.s.ctx, auth.AuthenticateParamIndex{}, a.s.consistIndex.ConsistentIndex()), auth.AuthenticateParamSimpleTokenPrefix{}, r.SimpleToken)
 	resp, err := a.s.AuthStore().Authenticate(ctx, r.Name, r.Password)
 	if resp != nil {
 		resp.Header = newHeader(a.s)
@@ -770,53 +843,66 @@ func (s *kvSortByValue) Less(i, j int) bool {
 	return bytes.Compare(s.kvs[i].Value, s.kvs[j].Value) < 0
 }
 
-func (a *applierV3backend) checkRequestPut(rv mvcc.ReadView, reqs []*pb.RequestOp) error {
-	for _, requ := range reqs {
-		tv, ok := requ.Request.(*pb.RequestOp_RequestPut)
-		if !ok {
-			continue
-		}
-		preq := tv.RequestPut
-		if preq == nil {
-			continue
-		}
-		if preq.IgnoreValue || preq.IgnoreLease {
-			// expects previous key-value, error if not exist
-			rr, err := rv.Range(preq.Key, nil, mvcc.RangeOptions{})
+func checkRequests(rv mvcc.ReadView, rt *pb.TxnRequest, txnPath []bool, f checkReqFunc) (int, error) {
+	txnCount := 0
+	reqs := rt.Success
+	if !txnPath[0] {
+		reqs = rt.Failure
+	}
+	for _, req := range reqs {
+		if tv, ok := req.Request.(*pb.RequestOp_RequestTxn); ok && tv.RequestTxn != nil {
+			txns, err := checkRequests(rv, tv.RequestTxn, txnPath[1:], f)
 			if err != nil {
-				return err
+				return 0, err
 			}
-			if rr == nil || len(rr.KVs) == 0 {
-				return ErrKeyNotFound
-			}
-		}
-		if lease.LeaseID(preq.Lease) == lease.NoLease {
+			txnCount += txns + 1
+			txnPath = txnPath[txns+1:]
 			continue
 		}
-		if l := a.s.lessor.Lookup(lease.LeaseID(preq.Lease)); l == nil {
+		if err := f(rv, req); err != nil {
+			return 0, err
+		}
+	}
+	return txnCount, nil
+}
+
+func (a *applierV3backend) checkRequestPut(rv mvcc.ReadView, reqOp *pb.RequestOp) error {
+	tv, ok := reqOp.Request.(*pb.RequestOp_RequestPut)
+	if !ok || tv.RequestPut == nil {
+		return nil
+	}
+	req := tv.RequestPut
+	if req.IgnoreValue || req.IgnoreLease {
+		// expects previous key-value, error if not exist
+		rr, err := rv.Range(req.Key, nil, mvcc.RangeOptions{})
+		if err != nil {
+			return err
+		}
+		if rr == nil || len(rr.KVs) == 0 {
+			return ErrKeyNotFound
+		}
+	}
+	if lease.LeaseID(req.Lease) != lease.NoLease {
+		if l := a.s.lessor.Lookup(lease.LeaseID(req.Lease)); l == nil {
 			return lease.ErrLeaseNotFound
 		}
 	}
 	return nil
 }
 
-func checkRequestRange(rv mvcc.ReadView, reqs []*pb.RequestOp) error {
-	for _, requ := range reqs {
-		tv, ok := requ.Request.(*pb.RequestOp_RequestRange)
-		if !ok {
-			continue
-		}
-		greq := tv.RequestRange
-		if greq == nil || greq.Revision == 0 {
-			continue
-		}
-
-		if greq.Revision > rv.Rev() {
-			return mvcc.ErrFutureRev
-		}
-		if greq.Revision < rv.FirstRev() {
-			return mvcc.ErrCompacted
-		}
+func (a *applierV3backend) checkRequestRange(rv mvcc.ReadView, reqOp *pb.RequestOp) error {
+	tv, ok := reqOp.Request.(*pb.RequestOp_RequestRange)
+	if !ok || tv.RequestRange == nil {
+		return nil
+	}
+	req := tv.RequestRange
+	switch {
+	case req.Revision == 0:
+		return nil
+	case req.Revision > rv.Rev():
+		return mvcc.ErrFutureRev
+	case req.Revision < rv.FirstRev():
+		return mvcc.ErrCompacted
 	}
 	return nil
 }
@@ -832,10 +918,15 @@ func compareInt64(a, b int64) int {
 	}
 }
 
-// isGteRange determines if the range end is a >= range. This works around grpc
+// mkGteRange determines if the range end is a >= range. This works around grpc
 // sending empty byte strings as nil; >= is encoded in the range end as '\0'.
-func isGteRange(rangeEnd []byte) bool {
-	return len(rangeEnd) == 1 && rangeEnd[0] == 0
+// If it is a GTE range, then []byte{} is returned to indicate the empty byte
+// string (vs nil being no byte string).
+func mkGteRange(rangeEnd []byte) []byte {
+	if len(rangeEnd) == 1 && rangeEnd[0] == 0 {
+		return []byte{}
+	}
+	return rangeEnd
 }
 
 func noSideEffect(r *pb.InternalRaftRequest) bool {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/apply_auth.go b/vendor/github.com/coreos/etcd/etcdserver/apply_auth.go
index 7da4ae45df5..ec9391435da 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/apply_auth.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/apply_auth.go
@@ -19,12 +19,14 @@ import (
 
 	"github.com/coreos/etcd/auth"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/lease"
 	"github.com/coreos/etcd/mvcc"
 )
 
 type authApplierV3 struct {
 	applierV3
-	as auth.AuthStore
+	as     auth.AuthStore
+	lessor lease.Lessor
 
 	// mu serializes Apply so that user isn't corrupted and so that
 	// serialized requests don't leak data from TOCTOU errors
@@ -33,8 +35,8 @@ type authApplierV3 struct {
 	authInfo auth.AuthInfo
 }
 
-func newAuthApplierV3(as auth.AuthStore, base applierV3) *authApplierV3 {
-	return &authApplierV3{applierV3: base, as: as}
+func newAuthApplierV3(as auth.AuthStore, base applierV3, lessor lease.Lessor) *authApplierV3 {
+	return &authApplierV3{applierV3: base, as: as, lessor: lessor}
 }
 
 func (aa *authApplierV3) Apply(r *pb.InternalRaftRequest) *applyResult {
@@ -63,6 +65,15 @@ func (aa *authApplierV3) Put(txn mvcc.TxnWrite, r *pb.PutRequest) (*pb.PutRespon
 	if err := aa.as.IsPutPermitted(&aa.authInfo, r.Key); err != nil {
 		return nil, err
 	}
+
+	if err := aa.checkLeasePuts(lease.LeaseID(r.Lease)); err != nil {
+		// The specified lease is already attached with a key that cannot
+		// be written by this user. It means the user cannot revoke the
+		// lease so attaching the lease to the newly written key should
+		// be forbidden.
+		return nil, err
+	}
+
 	if r.PrevKv {
 		err := aa.as.IsRangePermitted(&aa.authInfo, r.Key, nil)
 		if err != nil {
@@ -138,7 +149,7 @@ func checkTxnReqsPermission(as auth.AuthStore, ai *auth.AuthInfo, reqs []*pb.Req
 
 func checkTxnAuth(as auth.AuthStore, ai *auth.AuthInfo, rt *pb.TxnRequest) error {
 	for _, c := range rt.Compare {
-		if err := as.IsRangePermitted(ai, c.Key, nil); err != nil {
+		if err := as.IsRangePermitted(ai, c.Key, c.RangeEnd); err != nil {
 			return err
 		}
 	}
@@ -158,6 +169,48 @@ func (aa *authApplierV3) Txn(rt *pb.TxnRequest) (*pb.TxnResponse, error) {
 	return aa.applierV3.Txn(rt)
 }
 
+func (aa *authApplierV3) LeaseRevoke(lc *pb.LeaseRevokeRequest) (*pb.LeaseRevokeResponse, error) {
+	if err := aa.checkLeasePuts(lease.LeaseID(lc.ID)); err != nil {
+		return nil, err
+	}
+	return aa.applierV3.LeaseRevoke(lc)
+}
+
+func (aa *authApplierV3) checkLeasePuts(leaseID lease.LeaseID) error {
+	lease := aa.lessor.Lookup(leaseID)
+	if lease != nil {
+		for _, key := range lease.Keys() {
+			if err := aa.as.IsPutPermitted(&aa.authInfo, []byte(key)); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (aa *authApplierV3) UserGet(r *pb.AuthUserGetRequest) (*pb.AuthUserGetResponse, error) {
+	err := aa.as.IsAdminPermitted(&aa.authInfo)
+	if err != nil && r.Name != aa.authInfo.Username {
+		aa.authInfo.Username = ""
+		aa.authInfo.Revision = 0
+		return &pb.AuthUserGetResponse{}, err
+	}
+
+	return aa.applierV3.UserGet(r)
+}
+
+func (aa *authApplierV3) RoleGet(r *pb.AuthRoleGetRequest) (*pb.AuthRoleGetResponse, error) {
+	err := aa.as.IsAdminPermitted(&aa.authInfo)
+	if err != nil && !aa.as.HasRole(aa.authInfo.Username, r.Role) {
+		aa.authInfo.Username = ""
+		aa.authInfo.Revision = 0
+		return &pb.AuthRoleGetResponse{}, err
+	}
+
+	return aa.applierV3.RoleGet(r)
+}
+
 func needAdminPermission(r *pb.InternalRaftRequest) bool {
 	switch {
 	case r.AuthEnable != nil:
@@ -172,16 +225,12 @@ func needAdminPermission(r *pb.InternalRaftRequest) bool {
 		return true
 	case r.AuthUserGrantRole != nil:
 		return true
-	case r.AuthUserGet != nil:
-		return true
 	case r.AuthUserRevokeRole != nil:
 		return true
 	case r.AuthRoleAdd != nil:
 		return true
 	case r.AuthRoleGrantPermission != nil:
 		return true
-	case r.AuthRoleGet != nil:
-		return true
 	case r.AuthRoleRevokePermission != nil:
 		return true
 	case r.AuthRoleDelete != nil:
diff --git a/vendor/github.com/coreos/etcd/etcdserver/apply_v2.go b/vendor/github.com/coreos/etcd/etcdserver/apply_v2.go
index 67f30a0bb81..a49b6823da9 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/apply_v2.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/apply_v2.go
@@ -20,7 +20,6 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/etcdserver/api"
-	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/etcdserver/membership"
 	"github.com/coreos/etcd/pkg/pbutil"
 	"github.com/coreos/etcd/store"
@@ -29,11 +28,11 @@ import (
 
 // ApplierV2 is the interface for processing V2 raft messages
 type ApplierV2 interface {
-	Delete(r *pb.Request) Response
-	Post(r *pb.Request) Response
-	Put(r *pb.Request) Response
-	QGet(r *pb.Request) Response
-	Sync(r *pb.Request) Response
+	Delete(r *RequestV2) Response
+	Post(r *RequestV2) Response
+	Put(r *RequestV2) Response
+	QGet(r *RequestV2) Response
+	Sync(r *RequestV2) Response
 }
 
 func NewApplierV2(s store.Store, c *membership.RaftCluster) ApplierV2 {
@@ -45,7 +44,7 @@ type applierV2store struct {
 	cluster *membership.RaftCluster
 }
 
-func (a *applierV2store) Delete(r *pb.Request) Response {
+func (a *applierV2store) Delete(r *RequestV2) Response {
 	switch {
 	case r.PrevIndex > 0 || r.PrevValue != "":
 		return toResponse(a.store.CompareAndDelete(r.Path, r.PrevValue, r.PrevIndex))
@@ -54,12 +53,12 @@ func (a *applierV2store) Delete(r *pb.Request) Response {
 	}
 }
 
-func (a *applierV2store) Post(r *pb.Request) Response {
-	return toResponse(a.store.Create(r.Path, r.Dir, r.Val, true, toTTLOptions(r)))
+func (a *applierV2store) Post(r *RequestV2) Response {
+	return toResponse(a.store.Create(r.Path, r.Dir, r.Val, true, r.TTLOptions()))
 }
 
-func (a *applierV2store) Put(r *pb.Request) Response {
-	ttlOptions := toTTLOptions(r)
+func (a *applierV2store) Put(r *RequestV2) Response {
+	ttlOptions := r.TTLOptions()
 	exists, existsSet := pbutil.GetBool(r.PrevExist)
 	switch {
 	case existsSet:
@@ -96,20 +95,19 @@ func (a *applierV2store) Put(r *pb.Request) Response {
 	}
 }
 
-func (a *applierV2store) QGet(r *pb.Request) Response {
+func (a *applierV2store) QGet(r *RequestV2) Response {
 	return toResponse(a.store.Get(r.Path, r.Recursive, r.Sorted))
 }
 
-func (a *applierV2store) Sync(r *pb.Request) Response {
+func (a *applierV2store) Sync(r *RequestV2) Response {
 	a.store.DeleteExpiredKeys(time.Unix(0, r.Time))
 	return Response{}
 }
 
-// applyV2Request interprets r as a call to v2store.X
-// and returns a Response interpreted from v2store.Event
-func (s *EtcdServer) applyV2Request(r *pb.Request) Response {
+// applyV2Request interprets r as a call to store.X and returns a Response interpreted
+// from store.Event
+func (s *EtcdServer) applyV2Request(r *RequestV2) Response {
 	defer warnOfExpensiveRequest(time.Now(), r, nil, nil)
-	toTTLOptions(r)
 
 	switch r.Method {
 	case "POST":
@@ -124,11 +122,11 @@ func (s *EtcdServer) applyV2Request(r *pb.Request) Response {
 		return s.applyV2.Sync(r)
 	default:
 		// This should never be reached, but just in case:
-		return Response{err: ErrUnknownMethod}
+		return Response{Err: ErrUnknownMethod}
 	}
 }
 
-func toTTLOptions(r *pb.Request) store.TTLOptionSet {
+func (r *RequestV2) TTLOptions() store.TTLOptionSet {
 	refresh, _ := pbutil.GetBool(r.Refresh)
 	ttlOptions := store.TTLOptionSet{Refresh: refresh}
 	if r.Expiration != 0 {
@@ -138,5 +136,5 @@ func toTTLOptions(r *pb.Request) store.TTLOptionSet {
 }
 
 func toResponse(ev *store.Event, err error) Response {
-	return Response{Event: ev, err: err}
+	return Response{Event: ev, Err: err}
 }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/auth/BUILD b/vendor/github.com/coreos/etcd/etcdserver/auth/BUILD
index c2cacfdffbf..7b4031855cb 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/auth/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/auth/BUILD
@@ -16,7 +16,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/pkg/types:go_default_library",
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
         "//vendor/golang.org/x/crypto/bcrypt:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/etcdserver/auth/auth.go b/vendor/github.com/coreos/etcd/etcdserver/auth/auth.go
index 19e96d57c6d..8991675cc71 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/auth/auth.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/auth/auth.go
@@ -16,6 +16,7 @@
 package auth
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -30,8 +31,8 @@ import (
 	"github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/pkg/types"
 	"github.com/coreos/pkg/capnslog"
+
 	"golang.org/x/crypto/bcrypt"
-	"golang.org/x/net/context"
 )
 
 const (
diff --git a/vendor/github.com/coreos/etcd/etcdserver/auth/auth_requests.go b/vendor/github.com/coreos/etcd/etcdserver/auth/auth_requests.go
index eec700accd7..2464828e654 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/auth/auth_requests.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/auth/auth_requests.go
@@ -15,13 +15,13 @@
 package auth
 
 import (
+	"context"
 	"encoding/json"
 	"path"
 
 	etcderr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/etcdserverpb"
-	"golang.org/x/net/context"
 )
 
 func (s *store) ensureAuthDirectories() error {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/backend.go b/vendor/github.com/coreos/etcd/etcdserver/backend.go
index c5e2dabf3e7..647773d474f 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/backend.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/backend.go
@@ -26,7 +26,7 @@ import (
 	"github.com/coreos/etcd/snap"
 )
 
-func newBackend(cfg *ServerConfig) backend.Backend {
+func newBackend(cfg ServerConfig) backend.Backend {
 	bcfg := backend.DefaultBackendConfig()
 	bcfg.Path = cfg.backendPath()
 	if cfg.QuotaBackendBytes > 0 && cfg.QuotaBackendBytes != DefaultQuotaBytes {
@@ -37,7 +37,7 @@ func newBackend(cfg *ServerConfig) backend.Backend {
 }
 
 // openSnapshotBackend renames a snapshot db to the current etcd db and opens it.
-func openSnapshotBackend(cfg *ServerConfig, ss *snap.Snapshotter, snapshot raftpb.Snapshot) (backend.Backend, error) {
+func openSnapshotBackend(cfg ServerConfig, ss *snap.Snapshotter, snapshot raftpb.Snapshot) (backend.Backend, error) {
 	snapPath, err := ss.DBFilePath(snapshot.Metadata.Index)
 	if err != nil {
 		return nil, fmt.Errorf("database snapshot file path error: %v", err)
@@ -49,7 +49,7 @@ func openSnapshotBackend(cfg *ServerConfig, ss *snap.Snapshotter, snapshot raftp
 }
 
 // openBackend returns a backend using the current etcd db.
-func openBackend(cfg *ServerConfig) backend.Backend {
+func openBackend(cfg ServerConfig) backend.Backend {
 	fn := cfg.backendPath()
 	beOpened := make(chan backend.Backend)
 	go func() {
@@ -58,8 +58,8 @@ func openBackend(cfg *ServerConfig) backend.Backend {
 	select {
 	case be := <-beOpened:
 		return be
-	case <-time.After(time.Second):
-		plog.Warningf("another etcd process is using %q and holds the file lock.", fn)
+	case <-time.After(10 * time.Second):
+		plog.Warningf("another etcd process is using %q and holds the file lock, or loading backend file is taking >10 seconds", fn)
 		plog.Warningf("waiting for it to exit before starting...")
 	}
 	return <-beOpened
@@ -69,7 +69,7 @@ func openBackend(cfg *ServerConfig) backend.Backend {
 // before updating the backend db after persisting raft snapshot to disk,
 // violating the invariant snapshot.Metadata.Index < db.consistentIndex. In this
 // case, replace the db with the snapshot db sent by the leader.
-func recoverSnapshotBackend(cfg *ServerConfig, oldbe backend.Backend, snapshot raftpb.Snapshot) (backend.Backend, error) {
+func recoverSnapshotBackend(cfg ServerConfig, oldbe backend.Backend, snapshot raftpb.Snapshot) (backend.Backend, error) {
 	var cIndex consistentIndex
 	kv := mvcc.New(oldbe, &lease.FakeLessor{}, &cIndex)
 	defer kv.Close()
diff --git a/vendor/github.com/coreos/etcd/etcdserver/config.go b/vendor/github.com/coreos/etcd/etcdserver/config.go
index cd8eecea7f9..295d95299a2 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/config.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/config.go
@@ -15,14 +15,13 @@
 package etcdserver
 
 import (
+	"context"
 	"fmt"
 	"path/filepath"
 	"sort"
 	"strings"
 	"time"
 
-	"golang.org/x/net/context"
-
 	"github.com/coreos/etcd/pkg/netutil"
 	"github.com/coreos/etcd/pkg/transport"
 	"github.com/coreos/etcd/pkg/types"
@@ -82,8 +81,10 @@ type ServerConfig struct {
 
 	BootstrapTimeout time.Duration
 
-	AutoCompactionRetention int
+	AutoCompactionRetention time.Duration
+	AutoCompactionMode      string
 	QuotaBackendBytes       int64
+	MaxTxnOps               uint
 
 	// MaxRequestBytes is the maximum request size to send over raft.
 	MaxRequestBytes uint
@@ -95,6 +96,11 @@ type ServerConfig struct {
 
 	AuthToken string
 
+	// InitialCorruptCheck is true to check data corruption on boot
+	// before serving any peer/client traffic.
+	InitialCorruptCheck bool
+	CorruptCheckTime    time.Duration
+
 	Debug bool
 }
 
@@ -148,11 +154,49 @@ func (c *ServerConfig) advertiseMatchesCluster() error {
 	sort.Strings(apurls)
 	ctx, cancel := context.WithTimeout(context.TODO(), 30*time.Second)
 	defer cancel()
-	if !netutil.URLStringsEqual(ctx, apurls, urls.StringSlice()) {
-		umap := map[string]types.URLs{c.Name: c.PeerURLs}
-		return fmt.Errorf("--initial-cluster must include %s given --initial-advertise-peer-urls=%s", types.URLsMap(umap).String(), strings.Join(apurls, ","))
+	ok, err := netutil.URLStringsEqual(ctx, apurls, urls.StringSlice())
+	if ok {
+		return nil
 	}
-	return nil
+
+	initMap, apMap := make(map[string]struct{}), make(map[string]struct{})
+	for _, url := range c.PeerURLs {
+		apMap[url.String()] = struct{}{}
+	}
+	for _, url := range c.InitialPeerURLsMap[c.Name] {
+		initMap[url.String()] = struct{}{}
+	}
+
+	missing := []string{}
+	for url := range initMap {
+		if _, ok := apMap[url]; !ok {
+			missing = append(missing, url)
+		}
+	}
+	if len(missing) > 0 {
+		for i := range missing {
+			missing[i] = c.Name + "=" + missing[i]
+		}
+		mstr := strings.Join(missing, ",")
+		apStr := strings.Join(apurls, ",")
+		return fmt.Errorf("--initial-cluster has %s but missing from --initial-advertise-peer-urls=%s (%v)", mstr, apStr, err)
+	}
+
+	for url := range apMap {
+		if _, ok := initMap[url]; !ok {
+			missing = append(missing, url)
+		}
+	}
+	if len(missing) > 0 {
+		mstr := strings.Join(missing, ",")
+		umap := types.URLsMap(map[string]types.URLs{c.Name: c.PeerURLs})
+		return fmt.Errorf("--initial-advertise-peer-urls has %s but missing from --initial-cluster=%s", mstr, umap.String())
+	}
+
+	// resolved URLs from "--initial-advertise-peer-urls" and "--initial-cluster" did not match or failed
+	apStr := strings.Join(apurls, ",")
+	umap := types.URLsMap(map[string]types.URLs{c.Name: c.PeerURLs})
+	return fmt.Errorf("failed to resolve %s to match --initial-cluster=%s (%v)", apStr, umap.String(), err)
 }
 
 func (c *ServerConfig) MemberDir() string { return filepath.Join(c.DataDir, "member") }
@@ -172,17 +216,16 @@ func (c *ServerConfig) ShouldDiscover() bool { return c.DiscoveryURL != "" }
 func (c *ServerConfig) ReqTimeout() time.Duration {
 	// 5s for queue waiting, computation and disk IO delay
 	// + 2 * election timeout for possible leader election
-	return 5*time.Second + 2*time.Duration(c.ElectionTicks)*time.Duration(c.TickMs)*time.Millisecond
+	return 5*time.Second + 2*time.Duration(c.ElectionTicks*int(c.TickMs))*time.Millisecond
 }
 
 func (c *ServerConfig) electionTimeout() time.Duration {
-	return time.Duration(c.ElectionTicks) * time.Duration(c.TickMs) * time.Millisecond
+	return time.Duration(c.ElectionTicks*int(c.TickMs)) * time.Millisecond
 }
 
 func (c *ServerConfig) peerDialTimeout() time.Duration {
-	// 1s for queue wait and system delay
-	// + one RTT, which is smaller than 1/5 election timeout
-	return time.Second + time.Duration(c.ElectionTicks)*time.Duration(c.TickMs)*time.Millisecond/5
+	// 1s for queue wait and election timeout
+	return time.Second + time.Duration(c.ElectionTicks*int(c.TickMs))*time.Millisecond
 }
 
 func (c *ServerConfig) PrintWithInitial() { c.print(true) }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/corrupt.go b/vendor/github.com/coreos/etcd/etcdserver/corrupt.go
new file mode 100644
index 00000000000..d998ec59020
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/corrupt.go
@@ -0,0 +1,262 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package etcdserver
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/coreos/etcd/clientv3"
+	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/mvcc"
+	"github.com/coreos/etcd/pkg/types"
+)
+
+// CheckInitialHashKV compares initial hash values with its peers
+// before serving any peer/client traffic. Only mismatch when hashes
+// are different at requested revision, with same compact revision.
+func (s *EtcdServer) CheckInitialHashKV() error {
+	if !s.Cfg.InitialCorruptCheck {
+		return nil
+	}
+
+	plog.Infof("%s starting initial corruption check with timeout %v...", s.ID(), s.Cfg.ReqTimeout())
+	h, rev, crev, err := s.kv.HashByRev(0)
+	if err != nil {
+		return fmt.Errorf("%s failed to fetch hash (%v)", s.ID(), err)
+	}
+	peers := s.getPeerHashKVs(rev)
+	mismatch := 0
+	for _, p := range peers {
+		if p.resp != nil {
+			peerID := types.ID(p.resp.Header.MemberId)
+			if h != p.resp.Hash {
+				if crev == p.resp.CompactRevision {
+					plog.Errorf("%s's hash %d != %s's hash %d (revision %d, peer revision %d, compact revision %d)", s.ID(), h, peerID, p.resp.Hash, rev, p.resp.Header.Revision, crev)
+					mismatch++
+				} else {
+					plog.Warningf("%s cannot check hash of peer(%s): peer has a different compact revision %d (revision:%d)", s.ID(), peerID, p.resp.CompactRevision, rev)
+				}
+			}
+			continue
+		}
+		if p.err != nil {
+			switch p.err {
+			case rpctypes.ErrFutureRev:
+				plog.Warningf("%s cannot check the hash of peer(%q) at revision %d: peer is lagging behind(%q)", s.ID(), p.eps, rev, p.err.Error())
+			case rpctypes.ErrCompacted:
+				plog.Warningf("%s cannot check the hash of peer(%q) at revision %d: local node is lagging behind(%q)", s.ID(), p.eps, rev, p.err.Error())
+			}
+		}
+	}
+	if mismatch > 0 {
+		return fmt.Errorf("%s found data inconsistency with peers", s.ID())
+	}
+
+	plog.Infof("%s succeeded on initial corruption checking: no corruption", s.ID())
+	return nil
+}
+
+func (s *EtcdServer) monitorKVHash() {
+	t := s.Cfg.CorruptCheckTime
+	if t == 0 {
+		return
+	}
+	plog.Infof("enabled corruption checking with %s interval", t)
+	for {
+		select {
+		case <-s.stopping:
+			return
+		case <-time.After(t):
+		}
+		if !s.isLeader() {
+			continue
+		}
+		if err := s.checkHashKV(); err != nil {
+			plog.Debugf("check hash kv failed %v", err)
+		}
+	}
+}
+
+func (s *EtcdServer) checkHashKV() error {
+	h, rev, crev, err := s.kv.HashByRev(0)
+	if err != nil {
+		plog.Fatalf("failed to hash kv store (%v)", err)
+	}
+	peers := s.getPeerHashKVs(rev)
+
+	ctx, cancel := context.WithTimeout(context.Background(), s.Cfg.ReqTimeout())
+	err = s.linearizableReadNotify(ctx)
+	cancel()
+	if err != nil {
+		return err
+	}
+
+	h2, rev2, crev2, err := s.kv.HashByRev(0)
+	if err != nil {
+		plog.Warningf("failed to hash kv store (%v)", err)
+		return err
+	}
+
+	alarmed := false
+	mismatch := func(id uint64) {
+		if alarmed {
+			return
+		}
+		alarmed = true
+		a := &pb.AlarmRequest{
+			MemberID: uint64(id),
+			Action:   pb.AlarmRequest_ACTIVATE,
+			Alarm:    pb.AlarmType_CORRUPT,
+		}
+		s.goAttach(func() {
+			s.raftRequest(s.ctx, pb.InternalRaftRequest{Alarm: a})
+		})
+	}
+
+	if h2 != h && rev2 == rev && crev == crev2 {
+		plog.Warningf("mismatched hashes %d and %d for revision %d", h, h2, rev)
+		mismatch(uint64(s.ID()))
+	}
+
+	for _, p := range peers {
+		if p.resp == nil {
+			continue
+		}
+		id := p.resp.Header.MemberId
+
+		// leader expects follower's latest revision less than or equal to leader's
+		if p.resp.Header.Revision > rev2 {
+			plog.Warningf(
+				"revision %d from member %v, expected at most %d",
+				p.resp.Header.Revision,
+				types.ID(id),
+				rev2)
+			mismatch(id)
+		}
+
+		// leader expects follower's latest compact revision less than or equal to leader's
+		if p.resp.CompactRevision > crev2 {
+			plog.Warningf(
+				"compact revision %d from member %v, expected at most %d",
+				p.resp.CompactRevision,
+				types.ID(id),
+				crev2,
+			)
+			mismatch(id)
+		}
+
+		// follower's compact revision is leader's old one, then hashes must match
+		if p.resp.CompactRevision == crev && p.resp.Hash != h {
+			plog.Warningf(
+				"hash %d at revision %d from member %v, expected hash %d",
+				p.resp.Hash,
+				rev,
+				types.ID(id),
+				h,
+			)
+			mismatch(id)
+		}
+	}
+	return nil
+}
+
+type peerHashKVResp struct {
+	resp *clientv3.HashKVResponse
+	err  error
+	eps  []string
+}
+
+func (s *EtcdServer) getPeerHashKVs(rev int64) (resps []*peerHashKVResp) {
+	// TODO: handle the case when "s.cluster.Members" have not
+	// been populated (e.g. no snapshot to load from disk)
+	mbs := s.cluster.Members()
+	pURLs := make([][]string, len(mbs))
+	for _, m := range mbs {
+		if m.ID == s.ID() {
+			continue
+		}
+		pURLs = append(pURLs, m.PeerURLs)
+	}
+
+	for _, purls := range pURLs {
+		if len(purls) == 0 {
+			continue
+		}
+		cli, cerr := clientv3.New(clientv3.Config{
+			DialTimeout: s.Cfg.ReqTimeout(),
+			Endpoints:   purls,
+		})
+		if cerr != nil {
+			plog.Warningf("%s failed to create client to peer %q for hash checking (%q)", s.ID(), purls, cerr.Error())
+			continue
+		}
+
+		respsLen := len(resps)
+		for _, c := range cli.Endpoints() {
+			ctx, cancel := context.WithTimeout(context.Background(), s.Cfg.ReqTimeout())
+			var resp *clientv3.HashKVResponse
+			resp, cerr = cli.HashKV(ctx, c, rev)
+			cancel()
+			if cerr == nil {
+				resps = append(resps, &peerHashKVResp{resp: resp})
+				break
+			}
+			plog.Warningf("%s hash-kv error %q on peer %q with revision %d", s.ID(), cerr.Error(), c, rev)
+		}
+		cli.Close()
+
+		if respsLen == len(resps) {
+			resps = append(resps, &peerHashKVResp{err: cerr, eps: purls})
+		}
+	}
+	return resps
+}
+
+type applierV3Corrupt struct {
+	applierV3
+}
+
+func newApplierV3Corrupt(a applierV3) *applierV3Corrupt { return &applierV3Corrupt{a} }
+
+func (a *applierV3Corrupt) Put(txn mvcc.TxnWrite, p *pb.PutRequest) (*pb.PutResponse, error) {
+	return nil, ErrCorrupt
+}
+
+func (a *applierV3Corrupt) Range(txn mvcc.TxnRead, p *pb.RangeRequest) (*pb.RangeResponse, error) {
+	return nil, ErrCorrupt
+}
+
+func (a *applierV3Corrupt) DeleteRange(txn mvcc.TxnWrite, p *pb.DeleteRangeRequest) (*pb.DeleteRangeResponse, error) {
+	return nil, ErrCorrupt
+}
+
+func (a *applierV3Corrupt) Txn(rt *pb.TxnRequest) (*pb.TxnResponse, error) {
+	return nil, ErrCorrupt
+}
+
+func (a *applierV3Corrupt) Compaction(compaction *pb.CompactionRequest) (*pb.CompactionResponse, <-chan struct{}, error) {
+	return nil, nil, ErrCorrupt
+}
+
+func (a *applierV3Corrupt) LeaseGrant(lc *pb.LeaseGrantRequest) (*pb.LeaseGrantResponse, error) {
+	return nil, ErrCorrupt
+}
+
+func (a *applierV3Corrupt) LeaseRevoke(lc *pb.LeaseRevokeRequest) (*pb.LeaseRevokeResponse, error) {
+	return nil, ErrCorrupt
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/errors.go b/vendor/github.com/coreos/etcd/etcdserver/errors.go
index ed749dbe8d8..fb93c4b2a1d 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/errors.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/errors.go
@@ -29,11 +29,13 @@ var (
 	ErrTimeoutLeaderTransfer      = errors.New("etcdserver: request timed out, leader transfer took too long")
 	ErrNotEnoughStartedMembers    = errors.New("etcdserver: re-configuration failed due to not enough started members")
 	ErrNoLeader                   = errors.New("etcdserver: no leader")
+	ErrNotLeader                  = errors.New("etcdserver: not leader")
 	ErrRequestTooLarge            = errors.New("etcdserver: request is too large")
 	ErrNoSpace                    = errors.New("etcdserver: no space")
 	ErrTooManyRequests            = errors.New("etcdserver: too many requests")
 	ErrUnhealthy                  = errors.New("etcdserver: unhealthy cluster")
 	ErrKeyNotFound                = errors.New("etcdserver: key not found")
+	ErrCorrupt                    = errors.New("etcdserver: corrupt cluster")
 )
 
 type DiscoveryError struct {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/BUILD b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/BUILD
index e049213e6ab..7234b377330 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/BUILD
@@ -14,9 +14,9 @@ go_library(
     deps = [
         "//vendor/github.com/coreos/etcd/auth/authpb:go_default_library",
         "//vendor/github.com/coreos/etcd/mvcc/mvccpb:go_default_library",
+        "//vendor/github.com/gogo/protobuf/gogoproto:go_default_library",
         "//vendor/github.com/golang/protobuf/proto:go_default_library",
         "//vendor/golang.org/x/net/context:go_default_library",
-        "//vendor/google.golang.org/genproto/googleapis/api/annotations:go_default_library",
         "//vendor/google.golang.org/grpc:go_default_library",
     ],
 )
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.pb.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.pb.go
index aabf90061f6..90045a5c975 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.pb.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: etcdserver.proto
-// DO NOT EDIT!
 
 /*
 	Package etcdserverpb is a generated protocol buffer package.
@@ -32,6 +31,8 @@
 		CompactionRequest
 		CompactionResponse
 		HashRequest
+		HashKVRequest
+		HashKVResponse
 		HashResponse
 		SnapshotRequest
 		SnapshotResponse
@@ -47,6 +48,9 @@
 		LeaseKeepAliveResponse
 		LeaseTimeToLiveRequest
 		LeaseTimeToLiveResponse
+		LeaseLeasesRequest
+		LeaseStatus
+		LeaseLeasesResponse
 		Member
 		MemberAddRequest
 		MemberAddResponse
@@ -58,6 +62,8 @@
 		MemberListResponse
 		DefragmentRequest
 		DefragmentResponse
+		MoveLeaderRequest
+		MoveLeaderResponse
 		AlarmRequest
 		AlarmMember
 		AlarmResponse
@@ -105,6 +111,8 @@ import (
 
 	math "math"
 
+	_ "github.com/gogo/protobuf/gogoproto"
+
 	io "io"
 )
 
@@ -311,24 +319,6 @@ func (m *Metadata) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Etcdserver(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Etcdserver(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintEtcdserver(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/gw/rpc.pb.gw.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/gw/rpc.pb.gw.go
index 02a23b78c10..c50525ba392 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/gw/rpc.pb.gw.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/gw/rpc.pb.gw.go
@@ -237,6 +237,19 @@ func request_Lease_LeaseTimeToLive_0(ctx context.Context, marshaler runtime.Mars
 
 }
 
+func request_Lease_LeaseLeases_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq etcdserverpb.LeaseLeasesRequest
+	var metadata runtime.ServerMetadata
+
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.LeaseLeases(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
 func request_Cluster_MemberAdd_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq etcdserverpb.MemberAddRequest
 	var metadata runtime.ServerMetadata
@@ -341,6 +354,19 @@ func request_Maintenance_Hash_0(ctx context.Context, marshaler runtime.Marshaler
 
 }
 
+func request_Maintenance_HashKV_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq etcdserverpb.HashKVRequest
+	var metadata runtime.ServerMetadata
+
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.HashKV(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
 func request_Maintenance_Snapshot_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (etcdserverpb.Maintenance_SnapshotClient, runtime.ServerMetadata, error) {
 	var protoReq etcdserverpb.SnapshotRequest
 	var metadata runtime.ServerMetadata
@@ -362,6 +388,19 @@ func request_Maintenance_Snapshot_0(ctx context.Context, marshaler runtime.Marsh
 
 }
 
+func request_Maintenance_MoveLeader_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq etcdserverpb.MoveLeaderRequest
+	var metadata runtime.ServerMetadata
+
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.MoveLeader(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
 func request_Auth_AuthEnable_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq etcdserverpb.AuthEnableRequest
 	var metadata runtime.ServerMetadata
@@ -609,7 +648,7 @@ func RegisterKVHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.Cl
 func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.KVClient) error {
 
 	mux.Handle("POST", pattern_KV_Range_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -638,7 +677,7 @@ func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client
 	})
 
 	mux.Handle("POST", pattern_KV_Put_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -667,7 +706,7 @@ func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client
 	})
 
 	mux.Handle("POST", pattern_KV_DeleteRange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -696,7 +735,7 @@ func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client
 	})
 
 	mux.Handle("POST", pattern_KV_Txn_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -725,7 +764,7 @@ func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client
 	})
 
 	mux.Handle("POST", pattern_KV_Compact_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -757,15 +796,15 @@ func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client
 }
 
 var (
-	pattern_KV_Range_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "range"}, ""))
+	pattern_KV_Range_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "kv", "range"}, ""))
 
-	pattern_KV_Put_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "put"}, ""))
+	pattern_KV_Put_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "kv", "put"}, ""))
 
-	pattern_KV_DeleteRange_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "deleterange"}, ""))
+	pattern_KV_DeleteRange_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "kv", "deleterange"}, ""))
 
-	pattern_KV_Txn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "txn"}, ""))
+	pattern_KV_Txn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "kv", "txn"}, ""))
 
-	pattern_KV_Compact_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "compaction"}, ""))
+	pattern_KV_Compact_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "kv", "compaction"}, ""))
 )
 
 var (
@@ -819,7 +858,7 @@ func RegisterWatchHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc
 func RegisterWatchHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.WatchClient) error {
 
 	mux.Handle("POST", pattern_Watch_Watch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -851,7 +890,7 @@ func RegisterWatchHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 }
 
 var (
-	pattern_Watch_Watch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v3alpha", "watch"}, ""))
+	pattern_Watch_Watch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v3beta", "watch"}, ""))
 )
 
 var (
@@ -897,7 +936,7 @@ func RegisterLeaseHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc
 func RegisterLeaseHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.LeaseClient) error {
 
 	mux.Handle("POST", pattern_Lease_LeaseGrant_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -926,7 +965,7 @@ func RegisterLeaseHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 	})
 
 	mux.Handle("POST", pattern_Lease_LeaseRevoke_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -955,7 +994,7 @@ func RegisterLeaseHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 	})
 
 	mux.Handle("POST", pattern_Lease_LeaseKeepAlive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -984,7 +1023,7 @@ func RegisterLeaseHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 	})
 
 	mux.Handle("POST", pattern_Lease_LeaseTimeToLive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1012,17 +1051,48 @@ func RegisterLeaseHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("POST", pattern_Lease_LeaseLeases_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		if cn, ok := w.(http.CloseNotifier); ok {
+			go func(done <-chan struct{}, closed <-chan bool) {
+				select {
+				case <-done:
+				case <-closed:
+					cancel()
+				}
+			}(ctx.Done(), cn.CloseNotify())
+		}
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Lease_LeaseLeases_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Lease_LeaseLeases_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
 var (
-	pattern_Lease_LeaseGrant_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "lease", "grant"}, ""))
+	pattern_Lease_LeaseGrant_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "lease", "grant"}, ""))
 
-	pattern_Lease_LeaseRevoke_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "kv", "lease", "revoke"}, ""))
+	pattern_Lease_LeaseRevoke_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "kv", "lease", "revoke"}, ""))
 
-	pattern_Lease_LeaseKeepAlive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "lease", "keepalive"}, ""))
+	pattern_Lease_LeaseKeepAlive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "lease", "keepalive"}, ""))
 
-	pattern_Lease_LeaseTimeToLive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "kv", "lease", "timetolive"}, ""))
+	pattern_Lease_LeaseTimeToLive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "kv", "lease", "timetolive"}, ""))
+
+	pattern_Lease_LeaseLeases_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "kv", "lease", "leases"}, ""))
 )
 
 var (
@@ -1033,6 +1103,8 @@ var (
 	forward_Lease_LeaseKeepAlive_0 = runtime.ForwardResponseStream
 
 	forward_Lease_LeaseTimeToLive_0 = runtime.ForwardResponseMessage
+
+	forward_Lease_LeaseLeases_0 = runtime.ForwardResponseMessage
 )
 
 // RegisterClusterHandlerFromEndpoint is same as RegisterClusterHandler but
@@ -1074,7 +1146,7 @@ func RegisterClusterHandler(ctx context.Context, mux *runtime.ServeMux, conn *gr
 func RegisterClusterHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.ClusterClient) error {
 
 	mux.Handle("POST", pattern_Cluster_MemberAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1103,7 +1175,7 @@ func RegisterClusterHandlerClient(ctx context.Context, mux *runtime.ServeMux, cl
 	})
 
 	mux.Handle("POST", pattern_Cluster_MemberRemove_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1132,7 +1204,7 @@ func RegisterClusterHandlerClient(ctx context.Context, mux *runtime.ServeMux, cl
 	})
 
 	mux.Handle("POST", pattern_Cluster_MemberUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1161,7 +1233,7 @@ func RegisterClusterHandlerClient(ctx context.Context, mux *runtime.ServeMux, cl
 	})
 
 	mux.Handle("POST", pattern_Cluster_MemberList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1193,13 +1265,13 @@ func RegisterClusterHandlerClient(ctx context.Context, mux *runtime.ServeMux, cl
 }
 
 var (
-	pattern_Cluster_MemberAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "add"}, ""))
+	pattern_Cluster_MemberAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "cluster", "member", "add"}, ""))
 
-	pattern_Cluster_MemberRemove_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "remove"}, ""))
+	pattern_Cluster_MemberRemove_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "cluster", "member", "remove"}, ""))
 
-	pattern_Cluster_MemberUpdate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "update"}, ""))
+	pattern_Cluster_MemberUpdate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "cluster", "member", "update"}, ""))
 
-	pattern_Cluster_MemberList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "list"}, ""))
+	pattern_Cluster_MemberList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "cluster", "member", "list"}, ""))
 )
 
 var (
@@ -1251,7 +1323,7 @@ func RegisterMaintenanceHandler(ctx context.Context, mux *runtime.ServeMux, conn
 func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.MaintenanceClient) error {
 
 	mux.Handle("POST", pattern_Maintenance_Alarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1280,7 +1352,7 @@ func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux
 	})
 
 	mux.Handle("POST", pattern_Maintenance_Status_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1309,7 +1381,7 @@ func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux
 	})
 
 	mux.Handle("POST", pattern_Maintenance_Defragment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1338,7 +1410,7 @@ func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux
 	})
 
 	mux.Handle("POST", pattern_Maintenance_Hash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1366,8 +1438,37 @@ func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux
 
 	})
 
+	mux.Handle("POST", pattern_Maintenance_HashKV_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		if cn, ok := w.(http.CloseNotifier); ok {
+			go func(done <-chan struct{}, closed <-chan bool) {
+				select {
+				case <-done:
+				case <-closed:
+					cancel()
+				}
+			}(ctx.Done(), cn.CloseNotify())
+		}
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Maintenance_HashKV_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Maintenance_HashKV_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("POST", pattern_Maintenance_Snapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1395,19 +1496,52 @@ func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux
 
 	})
 
+	mux.Handle("POST", pattern_Maintenance_MoveLeader_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		if cn, ok := w.(http.CloseNotifier); ok {
+			go func(done <-chan struct{}, closed <-chan bool) {
+				select {
+				case <-done:
+				case <-closed:
+					cancel()
+				}
+			}(ctx.Done(), cn.CloseNotify())
+		}
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Maintenance_MoveLeader_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Maintenance_MoveLeader_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
 var (
-	pattern_Maintenance_Alarm_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "alarm"}, ""))
+	pattern_Maintenance_Alarm_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "alarm"}, ""))
 
-	pattern_Maintenance_Status_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "status"}, ""))
+	pattern_Maintenance_Status_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "status"}, ""))
 
-	pattern_Maintenance_Defragment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "defragment"}, ""))
+	pattern_Maintenance_Defragment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "defragment"}, ""))
 
-	pattern_Maintenance_Hash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "hash"}, ""))
+	pattern_Maintenance_Hash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "hash"}, ""))
 
-	pattern_Maintenance_Snapshot_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "snapshot"}, ""))
+	pattern_Maintenance_HashKV_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "hash"}, ""))
+
+	pattern_Maintenance_Snapshot_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "snapshot"}, ""))
+
+	pattern_Maintenance_MoveLeader_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "transfer-leadership"}, ""))
 )
 
 var (
@@ -1419,7 +1553,11 @@ var (
 
 	forward_Maintenance_Hash_0 = runtime.ForwardResponseMessage
 
+	forward_Maintenance_HashKV_0 = runtime.ForwardResponseMessage
+
 	forward_Maintenance_Snapshot_0 = runtime.ForwardResponseStream
+
+	forward_Maintenance_MoveLeader_0 = runtime.ForwardResponseMessage
 )
 
 // RegisterAuthHandlerFromEndpoint is same as RegisterAuthHandler but
@@ -1461,7 +1599,7 @@ func RegisterAuthHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.
 func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.AuthClient) error {
 
 	mux.Handle("POST", pattern_Auth_AuthEnable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1490,7 +1628,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_AuthDisable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1519,7 +1657,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_Authenticate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1548,7 +1686,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_UserAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1577,7 +1715,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_UserGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1606,7 +1744,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_UserList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1635,7 +1773,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_UserDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1664,7 +1802,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_UserChangePassword_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1693,7 +1831,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_UserGrantRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1722,7 +1860,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_UserRevokeRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1751,7 +1889,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_RoleAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1780,7 +1918,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_RoleGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1809,7 +1947,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_RoleList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1838,7 +1976,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_RoleDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1867,7 +2005,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_RoleGrantPermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1896,7 +2034,7 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 	})
 
 	mux.Handle("POST", pattern_Auth_RoleRevokePermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(ctx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
 			go func(done <-chan struct{}, closed <-chan bool) {
@@ -1928,37 +2066,37 @@ func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 }
 
 var (
-	pattern_Auth_AuthEnable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "auth", "enable"}, ""))
+	pattern_Auth_AuthEnable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "auth", "enable"}, ""))
 
-	pattern_Auth_AuthDisable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "auth", "disable"}, ""))
+	pattern_Auth_AuthDisable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "auth", "disable"}, ""))
 
-	pattern_Auth_Authenticate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "auth", "authenticate"}, ""))
+	pattern_Auth_Authenticate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "auth", "authenticate"}, ""))
 
-	pattern_Auth_UserAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "add"}, ""))
+	pattern_Auth_UserAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "add"}, ""))
 
-	pattern_Auth_UserGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "get"}, ""))
+	pattern_Auth_UserGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "get"}, ""))
 
-	pattern_Auth_UserList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "list"}, ""))
+	pattern_Auth_UserList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "list"}, ""))
 
-	pattern_Auth_UserDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "delete"}, ""))
+	pattern_Auth_UserDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "delete"}, ""))
 
-	pattern_Auth_UserChangePassword_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "changepw"}, ""))
+	pattern_Auth_UserChangePassword_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "changepw"}, ""))
 
-	pattern_Auth_UserGrantRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "grant"}, ""))
+	pattern_Auth_UserGrantRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "grant"}, ""))
 
-	pattern_Auth_UserRevokeRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "revoke"}, ""))
+	pattern_Auth_UserRevokeRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "revoke"}, ""))
 
-	pattern_Auth_RoleAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "add"}, ""))
+	pattern_Auth_RoleAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "add"}, ""))
 
-	pattern_Auth_RoleGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "get"}, ""))
+	pattern_Auth_RoleGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "get"}, ""))
 
-	pattern_Auth_RoleList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "list"}, ""))
+	pattern_Auth_RoleList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "list"}, ""))
 
-	pattern_Auth_RoleDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "delete"}, ""))
+	pattern_Auth_RoleDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "delete"}, ""))
 
-	pattern_Auth_RoleGrantPermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "grant"}, ""))
+	pattern_Auth_RoleGrantPermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "grant"}, ""))
 
-	pattern_Auth_RoleRevokePermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "revoke"}, ""))
+	pattern_Auth_RoleRevokePermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "revoke"}, ""))
 )
 
 var (
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.pb.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.pb.go
index 44a3b6f69eb..3084c6cbf86 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.pb.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: raft_internal.proto
-// DO NOT EDIT!
 
 package etcdserverpb
 
@@ -11,6 +10,8 @@ import (
 
 	math "math"
 
+	_ "github.com/gogo/protobuf/gogoproto"
+
 	io "io"
 )
 
@@ -505,24 +506,6 @@ func (m *InternalAuthenticateRequest) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64RaftInternal(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32RaftInternal(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintRaftInternal(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal_stringer.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal_stringer.go
index 362b252cade..ec6b6397b39 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal_stringer.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal_stringer.go
@@ -122,6 +122,8 @@ func (as *requestOpStringer) String() string {
 	switch op := as.Op.Request.(type) {
 	case *RequestOp_RequestPut:
 		return fmt.Sprintf("request_put:<%s>", newLoggablePutRequest(op.RequestPut).String())
+	case *RequestOp_RequestTxn:
+		return fmt.Sprintf("request_txn:<%s>", NewLoggableTxnRequest(op.RequestTxn).String())
 	default:
 		// nothing to redact
 	}
@@ -136,6 +138,7 @@ type loggableValueCompare struct {
 	Target    Compare_CompareTarget `protobuf:"varint,2,opt,name=target,proto3,enum=etcdserverpb.Compare_CompareTarget"`
 	Key       []byte                `protobuf:"bytes,3,opt,name=key,proto3"`
 	ValueSize int                   `protobuf:"bytes,7,opt,name=value_size,proto3"`
+	RangeEnd  []byte                `protobuf:"bytes,64,opt,name=range_end,proto3"`
 }
 
 func newLoggableValueCompare(c *Compare, cv *Compare_Value) *loggableValueCompare {
@@ -144,6 +147,7 @@ func newLoggableValueCompare(c *Compare, cv *Compare_Value) *loggableValueCompar
 		c.Target,
 		c.Key,
 		len(cv.Value),
+		c.RangeEnd,
 	}
 }
 
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.go
index 894c815f824..40147f935ab 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: rpc.proto
-// DO NOT EDIT!
 
 package etcdserverpb
 
@@ -11,12 +10,12 @@ import (
 
 	math "math"
 
+	_ "github.com/gogo/protobuf/gogoproto"
+
 	mvccpb "github.com/coreos/etcd/mvcc/mvccpb"
 
 	authpb "github.com/coreos/etcd/auth/authpb"
 
-	_ "google.golang.org/genproto/googleapis/api/annotations"
-
 	context "golang.org/x/net/context"
 
 	grpc "google.golang.org/grpc"
@@ -34,15 +33,18 @@ type AlarmType int32
 const (
 	AlarmType_NONE    AlarmType = 0
 	AlarmType_NOSPACE AlarmType = 1
+	AlarmType_CORRUPT AlarmType = 2
 )
 
 var AlarmType_name = map[int32]string{
 	0: "NONE",
 	1: "NOSPACE",
+	2: "CORRUPT",
 }
 var AlarmType_value = map[string]int32{
 	"NONE":    0,
 	"NOSPACE": 1,
+	"CORRUPT": 2,
 }
 
 func (x AlarmType) String() string {
@@ -138,6 +140,7 @@ const (
 	Compare_CREATE  Compare_CompareTarget = 1
 	Compare_MOD     Compare_CompareTarget = 2
 	Compare_VALUE   Compare_CompareTarget = 3
+	Compare_LEASE   Compare_CompareTarget = 4
 )
 
 var Compare_CompareTarget_name = map[int32]string{
@@ -145,12 +148,14 @@ var Compare_CompareTarget_name = map[int32]string{
 	1: "CREATE",
 	2: "MOD",
 	3: "VALUE",
+	4: "LEASE",
 }
 var Compare_CompareTarget_value = map[string]int32{
 	"VERSION": 0,
 	"CREATE":  1,
 	"MOD":     2,
 	"VALUE":   3,
+	"LEASE":   4,
 }
 
 func (x Compare_CompareTarget) String() string {
@@ -180,7 +185,7 @@ func (x WatchCreateRequest_FilterType) String() string {
 	return proto.EnumName(WatchCreateRequest_FilterType_name, int32(x))
 }
 func (WatchCreateRequest_FilterType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptorRpc, []int{19, 0}
+	return fileDescriptorRpc, []int{21, 0}
 }
 
 type AlarmRequest_AlarmAction int32
@@ -206,7 +211,7 @@ func (x AlarmRequest_AlarmAction) String() string {
 	return proto.EnumName(AlarmRequest_AlarmAction_name, int32(x))
 }
 func (AlarmRequest_AlarmAction) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptorRpc, []int{41, 0}
+	return fileDescriptorRpc, []int{48, 0}
 }
 
 type ResponseHeader struct {
@@ -610,6 +615,7 @@ type RequestOp struct {
 	//	*RequestOp_RequestRange
 	//	*RequestOp_RequestPut
 	//	*RequestOp_RequestDeleteRange
+	//	*RequestOp_RequestTxn
 	Request isRequestOp_Request `protobuf_oneof:"request"`
 }
 
@@ -633,10 +639,14 @@ type RequestOp_RequestPut struct {
 type RequestOp_RequestDeleteRange struct {
 	RequestDeleteRange *DeleteRangeRequest `protobuf:"bytes,3,opt,name=request_delete_range,json=requestDeleteRange,oneof"`
 }
+type RequestOp_RequestTxn struct {
+	RequestTxn *TxnRequest `protobuf:"bytes,4,opt,name=request_txn,json=requestTxn,oneof"`
+}
 
 func (*RequestOp_RequestRange) isRequestOp_Request()       {}
 func (*RequestOp_RequestPut) isRequestOp_Request()         {}
 func (*RequestOp_RequestDeleteRange) isRequestOp_Request() {}
+func (*RequestOp_RequestTxn) isRequestOp_Request()         {}
 
 func (m *RequestOp) GetRequest() isRequestOp_Request {
 	if m != nil {
@@ -666,12 +676,20 @@ func (m *RequestOp) GetRequestDeleteRange() *DeleteRangeRequest {
 	return nil
 }
 
+func (m *RequestOp) GetRequestTxn() *TxnRequest {
+	if x, ok := m.GetRequest().(*RequestOp_RequestTxn); ok {
+		return x.RequestTxn
+	}
+	return nil
+}
+
 // XXX_OneofFuncs is for the internal use of the proto package.
 func (*RequestOp) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 	return _RequestOp_OneofMarshaler, _RequestOp_OneofUnmarshaler, _RequestOp_OneofSizer, []interface{}{
 		(*RequestOp_RequestRange)(nil),
 		(*RequestOp_RequestPut)(nil),
 		(*RequestOp_RequestDeleteRange)(nil),
+		(*RequestOp_RequestTxn)(nil),
 	}
 }
 
@@ -694,6 +712,11 @@ func _RequestOp_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 		if err := b.EncodeMessage(x.RequestDeleteRange); err != nil {
 			return err
 		}
+	case *RequestOp_RequestTxn:
+		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.RequestTxn); err != nil {
+			return err
+		}
 	case nil:
 	default:
 		return fmt.Errorf("RequestOp.Request has unexpected type %T", x)
@@ -728,6 +751,14 @@ func _RequestOp_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buff
 		err := b.DecodeMessage(msg)
 		m.Request = &RequestOp_RequestDeleteRange{msg}
 		return true, err
+	case 4: // request.request_txn
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(TxnRequest)
+		err := b.DecodeMessage(msg)
+		m.Request = &RequestOp_RequestTxn{msg}
+		return true, err
 	default:
 		return false, nil
 	}
@@ -752,6 +783,11 @@ func _RequestOp_OneofSizer(msg proto.Message) (n int) {
 		n += proto.SizeVarint(3<<3 | proto.WireBytes)
 		n += proto.SizeVarint(uint64(s))
 		n += s
+	case *RequestOp_RequestTxn:
+		s := proto.Size(x.RequestTxn)
+		n += proto.SizeVarint(4<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
 	case nil:
 	default:
 		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
@@ -766,6 +802,7 @@ type ResponseOp struct {
 	//	*ResponseOp_ResponseRange
 	//	*ResponseOp_ResponsePut
 	//	*ResponseOp_ResponseDeleteRange
+	//	*ResponseOp_ResponseTxn
 	Response isResponseOp_Response `protobuf_oneof:"response"`
 }
 
@@ -789,10 +826,14 @@ type ResponseOp_ResponsePut struct {
 type ResponseOp_ResponseDeleteRange struct {
 	ResponseDeleteRange *DeleteRangeResponse `protobuf:"bytes,3,opt,name=response_delete_range,json=responseDeleteRange,oneof"`
 }
+type ResponseOp_ResponseTxn struct {
+	ResponseTxn *TxnResponse `protobuf:"bytes,4,opt,name=response_txn,json=responseTxn,oneof"`
+}
 
 func (*ResponseOp_ResponseRange) isResponseOp_Response()       {}
 func (*ResponseOp_ResponsePut) isResponseOp_Response()         {}
 func (*ResponseOp_ResponseDeleteRange) isResponseOp_Response() {}
+func (*ResponseOp_ResponseTxn) isResponseOp_Response()         {}
 
 func (m *ResponseOp) GetResponse() isResponseOp_Response {
 	if m != nil {
@@ -822,12 +863,20 @@ func (m *ResponseOp) GetResponseDeleteRange() *DeleteRangeResponse {
 	return nil
 }
 
+func (m *ResponseOp) GetResponseTxn() *TxnResponse {
+	if x, ok := m.GetResponse().(*ResponseOp_ResponseTxn); ok {
+		return x.ResponseTxn
+	}
+	return nil
+}
+
 // XXX_OneofFuncs is for the internal use of the proto package.
 func (*ResponseOp) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 	return _ResponseOp_OneofMarshaler, _ResponseOp_OneofUnmarshaler, _ResponseOp_OneofSizer, []interface{}{
 		(*ResponseOp_ResponseRange)(nil),
 		(*ResponseOp_ResponsePut)(nil),
 		(*ResponseOp_ResponseDeleteRange)(nil),
+		(*ResponseOp_ResponseTxn)(nil),
 	}
 }
 
@@ -850,6 +899,11 @@ func _ResponseOp_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 		if err := b.EncodeMessage(x.ResponseDeleteRange); err != nil {
 			return err
 		}
+	case *ResponseOp_ResponseTxn:
+		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.ResponseTxn); err != nil {
+			return err
+		}
 	case nil:
 	default:
 		return fmt.Errorf("ResponseOp.Response has unexpected type %T", x)
@@ -884,6 +938,14 @@ func _ResponseOp_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buf
 		err := b.DecodeMessage(msg)
 		m.Response = &ResponseOp_ResponseDeleteRange{msg}
 		return true, err
+	case 4: // response.response_txn
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(TxnResponse)
+		err := b.DecodeMessage(msg)
+		m.Response = &ResponseOp_ResponseTxn{msg}
+		return true, err
 	default:
 		return false, nil
 	}
@@ -908,6 +970,11 @@ func _ResponseOp_OneofSizer(msg proto.Message) (n int) {
 		n += proto.SizeVarint(3<<3 | proto.WireBytes)
 		n += proto.SizeVarint(uint64(s))
 		n += s
+	case *ResponseOp_ResponseTxn:
+		s := proto.Size(x.ResponseTxn)
+		n += proto.SizeVarint(4<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
 	case nil:
 	default:
 		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
@@ -927,7 +994,11 @@ type Compare struct {
 	//	*Compare_CreateRevision
 	//	*Compare_ModRevision
 	//	*Compare_Value
+	//	*Compare_Lease
 	TargetUnion isCompare_TargetUnion `protobuf_oneof:"target_union"`
+	// range_end compares the given target to all keys in the range [key, range_end).
+	// See RangeRequest for more details on key ranges.
+	RangeEnd []byte `protobuf:"bytes,64,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
 }
 
 func (m *Compare) Reset()                    { *m = Compare{} }
@@ -953,11 +1024,15 @@ type Compare_ModRevision struct {
 type Compare_Value struct {
 	Value []byte `protobuf:"bytes,7,opt,name=value,proto3,oneof"`
 }
+type Compare_Lease struct {
+	Lease int64 `protobuf:"varint,8,opt,name=lease,proto3,oneof"`
+}
 
 func (*Compare_Version) isCompare_TargetUnion()        {}
 func (*Compare_CreateRevision) isCompare_TargetUnion() {}
 func (*Compare_ModRevision) isCompare_TargetUnion()    {}
 func (*Compare_Value) isCompare_TargetUnion()          {}
+func (*Compare_Lease) isCompare_TargetUnion()          {}
 
 func (m *Compare) GetTargetUnion() isCompare_TargetUnion {
 	if m != nil {
@@ -1015,6 +1090,20 @@ func (m *Compare) GetValue() []byte {
 	return nil
 }
 
+func (m *Compare) GetLease() int64 {
+	if x, ok := m.GetTargetUnion().(*Compare_Lease); ok {
+		return x.Lease
+	}
+	return 0
+}
+
+func (m *Compare) GetRangeEnd() []byte {
+	if m != nil {
+		return m.RangeEnd
+	}
+	return nil
+}
+
 // XXX_OneofFuncs is for the internal use of the proto package.
 func (*Compare) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 	return _Compare_OneofMarshaler, _Compare_OneofUnmarshaler, _Compare_OneofSizer, []interface{}{
@@ -1022,6 +1111,7 @@ func (*Compare) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error
 		(*Compare_CreateRevision)(nil),
 		(*Compare_ModRevision)(nil),
 		(*Compare_Value)(nil),
+		(*Compare_Lease)(nil),
 	}
 }
 
@@ -1041,6 +1131,9 @@ func _Compare_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 	case *Compare_Value:
 		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
 		_ = b.EncodeRawBytes(x.Value)
+	case *Compare_Lease:
+		_ = b.EncodeVarint(8<<3 | proto.WireVarint)
+		_ = b.EncodeVarint(uint64(x.Lease))
 	case nil:
 	default:
 		return fmt.Errorf("Compare.TargetUnion has unexpected type %T", x)
@@ -1079,6 +1172,13 @@ func _Compare_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer
 		x, err := b.DecodeRawBytes(true)
 		m.TargetUnion = &Compare_Value{x}
 		return true, err
+	case 8: // target_union.lease
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.TargetUnion = &Compare_Lease{int64(x)}
+		return true, err
 	default:
 		return false, nil
 	}
@@ -1101,6 +1201,9 @@ func _Compare_OneofSizer(msg proto.Message) (n int) {
 		n += proto.SizeVarint(7<<3 | proto.WireBytes)
 		n += proto.SizeVarint(uint64(len(x.Value)))
 		n += len(x.Value)
+	case *Compare_Lease:
+		n += proto.SizeVarint(8<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Lease))
 	case nil:
 	default:
 		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
@@ -1251,16 +1354,67 @@ func (m *HashRequest) String() string            { return proto.CompactTextStrin
 func (*HashRequest) ProtoMessage()               {}
 func (*HashRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{14} }
 
+type HashKVRequest struct {
+	// revision is the key-value store revision for the hash operation.
+	Revision int64 `protobuf:"varint,1,opt,name=revision,proto3" json:"revision,omitempty"`
+}
+
+func (m *HashKVRequest) Reset()                    { *m = HashKVRequest{} }
+func (m *HashKVRequest) String() string            { return proto.CompactTextString(m) }
+func (*HashKVRequest) ProtoMessage()               {}
+func (*HashKVRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{15} }
+
+func (m *HashKVRequest) GetRevision() int64 {
+	if m != nil {
+		return m.Revision
+	}
+	return 0
+}
+
+type HashKVResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// hash is the hash value computed from the responding member's MVCC keys up to a given revision.
+	Hash uint32 `protobuf:"varint,2,opt,name=hash,proto3" json:"hash,omitempty"`
+	// compact_revision is the compacted revision of key-value store when hash begins.
+	CompactRevision int64 `protobuf:"varint,3,opt,name=compact_revision,json=compactRevision,proto3" json:"compact_revision,omitempty"`
+}
+
+func (m *HashKVResponse) Reset()                    { *m = HashKVResponse{} }
+func (m *HashKVResponse) String() string            { return proto.CompactTextString(m) }
+func (*HashKVResponse) ProtoMessage()               {}
+func (*HashKVResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{16} }
+
+func (m *HashKVResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *HashKVResponse) GetHash() uint32 {
+	if m != nil {
+		return m.Hash
+	}
+	return 0
+}
+
+func (m *HashKVResponse) GetCompactRevision() int64 {
+	if m != nil {
+		return m.CompactRevision
+	}
+	return 0
+}
+
 type HashResponse struct {
 	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
-	// hash is the hash value computed from the responding member's key-value store.
+	// hash is the hash value computed from the responding member's KV's backend.
 	Hash uint32 `protobuf:"varint,2,opt,name=hash,proto3" json:"hash,omitempty"`
 }
 
 func (m *HashResponse) Reset()                    { *m = HashResponse{} }
 func (m *HashResponse) String() string            { return proto.CompactTextString(m) }
 func (*HashResponse) ProtoMessage()               {}
-func (*HashResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{15} }
+func (*HashResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{17} }
 
 func (m *HashResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1282,7 +1436,7 @@ type SnapshotRequest struct {
 func (m *SnapshotRequest) Reset()                    { *m = SnapshotRequest{} }
 func (m *SnapshotRequest) String() string            { return proto.CompactTextString(m) }
 func (*SnapshotRequest) ProtoMessage()               {}
-func (*SnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{16} }
+func (*SnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{18} }
 
 type SnapshotResponse struct {
 	// header has the current key-value store information. The first header in the snapshot
@@ -1297,7 +1451,7 @@ type SnapshotResponse struct {
 func (m *SnapshotResponse) Reset()                    { *m = SnapshotResponse{} }
 func (m *SnapshotResponse) String() string            { return proto.CompactTextString(m) }
 func (*SnapshotResponse) ProtoMessage()               {}
-func (*SnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{17} }
+func (*SnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{19} }
 
 func (m *SnapshotResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1332,7 +1486,7 @@ type WatchRequest struct {
 func (m *WatchRequest) Reset()                    { *m = WatchRequest{} }
 func (m *WatchRequest) String() string            { return proto.CompactTextString(m) }
 func (*WatchRequest) ProtoMessage()               {}
-func (*WatchRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{18} }
+func (*WatchRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{20} }
 
 type isWatchRequest_RequestUnion interface {
 	isWatchRequest_RequestUnion()
@@ -1471,7 +1625,7 @@ type WatchCreateRequest struct {
 func (m *WatchCreateRequest) Reset()                    { *m = WatchCreateRequest{} }
 func (m *WatchCreateRequest) String() string            { return proto.CompactTextString(m) }
 func (*WatchCreateRequest) ProtoMessage()               {}
-func (*WatchCreateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{19} }
+func (*WatchCreateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{21} }
 
 func (m *WatchCreateRequest) GetKey() []byte {
 	if m != nil {
@@ -1523,7 +1677,7 @@ type WatchCancelRequest struct {
 func (m *WatchCancelRequest) Reset()                    { *m = WatchCancelRequest{} }
 func (m *WatchCancelRequest) String() string            { return proto.CompactTextString(m) }
 func (*WatchCancelRequest) ProtoMessage()               {}
-func (*WatchCancelRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{20} }
+func (*WatchCancelRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{22} }
 
 func (m *WatchCancelRequest) GetWatchId() int64 {
 	if m != nil {
@@ -1561,7 +1715,7 @@ type WatchResponse struct {
 func (m *WatchResponse) Reset()                    { *m = WatchResponse{} }
 func (m *WatchResponse) String() string            { return proto.CompactTextString(m) }
 func (*WatchResponse) ProtoMessage()               {}
-func (*WatchResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{21} }
+func (*WatchResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{23} }
 
 func (m *WatchResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1613,7 +1767,7 @@ func (m *WatchResponse) GetEvents() []*mvccpb.Event {
 }
 
 type LeaseGrantRequest struct {
-	// TTL is the advisory time-to-live in seconds.
+	// TTL is the advisory time-to-live in seconds. Expired lease will return -1.
 	TTL int64 `protobuf:"varint,1,opt,name=TTL,proto3" json:"TTL,omitempty"`
 	// ID is the requested ID for the lease. If ID is set to 0, the lessor chooses an ID.
 	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
@@ -1622,7 +1776,7 @@ type LeaseGrantRequest struct {
 func (m *LeaseGrantRequest) Reset()                    { *m = LeaseGrantRequest{} }
 func (m *LeaseGrantRequest) String() string            { return proto.CompactTextString(m) }
 func (*LeaseGrantRequest) ProtoMessage()               {}
-func (*LeaseGrantRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{22} }
+func (*LeaseGrantRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{24} }
 
 func (m *LeaseGrantRequest) GetTTL() int64 {
 	if m != nil {
@@ -1650,7 +1804,7 @@ type LeaseGrantResponse struct {
 func (m *LeaseGrantResponse) Reset()                    { *m = LeaseGrantResponse{} }
 func (m *LeaseGrantResponse) String() string            { return proto.CompactTextString(m) }
 func (*LeaseGrantResponse) ProtoMessage()               {}
-func (*LeaseGrantResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{23} }
+func (*LeaseGrantResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{25} }
 
 func (m *LeaseGrantResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1688,7 +1842,7 @@ type LeaseRevokeRequest struct {
 func (m *LeaseRevokeRequest) Reset()                    { *m = LeaseRevokeRequest{} }
 func (m *LeaseRevokeRequest) String() string            { return proto.CompactTextString(m) }
 func (*LeaseRevokeRequest) ProtoMessage()               {}
-func (*LeaseRevokeRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{24} }
+func (*LeaseRevokeRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{26} }
 
 func (m *LeaseRevokeRequest) GetID() int64 {
 	if m != nil {
@@ -1704,7 +1858,7 @@ type LeaseRevokeResponse struct {
 func (m *LeaseRevokeResponse) Reset()                    { *m = LeaseRevokeResponse{} }
 func (m *LeaseRevokeResponse) String() string            { return proto.CompactTextString(m) }
 func (*LeaseRevokeResponse) ProtoMessage()               {}
-func (*LeaseRevokeResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{25} }
+func (*LeaseRevokeResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{27} }
 
 func (m *LeaseRevokeResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1721,7 +1875,7 @@ type LeaseKeepAliveRequest struct {
 func (m *LeaseKeepAliveRequest) Reset()                    { *m = LeaseKeepAliveRequest{} }
 func (m *LeaseKeepAliveRequest) String() string            { return proto.CompactTextString(m) }
 func (*LeaseKeepAliveRequest) ProtoMessage()               {}
-func (*LeaseKeepAliveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{26} }
+func (*LeaseKeepAliveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{28} }
 
 func (m *LeaseKeepAliveRequest) GetID() int64 {
 	if m != nil {
@@ -1741,7 +1895,7 @@ type LeaseKeepAliveResponse struct {
 func (m *LeaseKeepAliveResponse) Reset()                    { *m = LeaseKeepAliveResponse{} }
 func (m *LeaseKeepAliveResponse) String() string            { return proto.CompactTextString(m) }
 func (*LeaseKeepAliveResponse) ProtoMessage()               {}
-func (*LeaseKeepAliveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{27} }
+func (*LeaseKeepAliveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{29} }
 
 func (m *LeaseKeepAliveResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1774,7 +1928,7 @@ type LeaseTimeToLiveRequest struct {
 func (m *LeaseTimeToLiveRequest) Reset()                    { *m = LeaseTimeToLiveRequest{} }
 func (m *LeaseTimeToLiveRequest) String() string            { return proto.CompactTextString(m) }
 func (*LeaseTimeToLiveRequest) ProtoMessage()               {}
-func (*LeaseTimeToLiveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{28} }
+func (*LeaseTimeToLiveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{30} }
 
 func (m *LeaseTimeToLiveRequest) GetID() int64 {
 	if m != nil {
@@ -1805,7 +1959,7 @@ type LeaseTimeToLiveResponse struct {
 func (m *LeaseTimeToLiveResponse) Reset()                    { *m = LeaseTimeToLiveResponse{} }
 func (m *LeaseTimeToLiveResponse) String() string            { return proto.CompactTextString(m) }
 func (*LeaseTimeToLiveResponse) ProtoMessage()               {}
-func (*LeaseTimeToLiveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{29} }
+func (*LeaseTimeToLiveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{31} }
 
 func (m *LeaseTimeToLiveResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1842,6 +1996,54 @@ func (m *LeaseTimeToLiveResponse) GetKeys() [][]byte {
 	return nil
 }
 
+type LeaseLeasesRequest struct {
+}
+
+func (m *LeaseLeasesRequest) Reset()                    { *m = LeaseLeasesRequest{} }
+func (m *LeaseLeasesRequest) String() string            { return proto.CompactTextString(m) }
+func (*LeaseLeasesRequest) ProtoMessage()               {}
+func (*LeaseLeasesRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{32} }
+
+type LeaseStatus struct {
+	ID int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+}
+
+func (m *LeaseStatus) Reset()                    { *m = LeaseStatus{} }
+func (m *LeaseStatus) String() string            { return proto.CompactTextString(m) }
+func (*LeaseStatus) ProtoMessage()               {}
+func (*LeaseStatus) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{33} }
+
+func (m *LeaseStatus) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+type LeaseLeasesResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	Leases []*LeaseStatus  `protobuf:"bytes,2,rep,name=leases" json:"leases,omitempty"`
+}
+
+func (m *LeaseLeasesResponse) Reset()                    { *m = LeaseLeasesResponse{} }
+func (m *LeaseLeasesResponse) String() string            { return proto.CompactTextString(m) }
+func (*LeaseLeasesResponse) ProtoMessage()               {}
+func (*LeaseLeasesResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{34} }
+
+func (m *LeaseLeasesResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *LeaseLeasesResponse) GetLeases() []*LeaseStatus {
+	if m != nil {
+		return m.Leases
+	}
+	return nil
+}
+
 type Member struct {
 	// ID is the member ID for this member.
 	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
@@ -1856,7 +2058,7 @@ type Member struct {
 func (m *Member) Reset()                    { *m = Member{} }
 func (m *Member) String() string            { return proto.CompactTextString(m) }
 func (*Member) ProtoMessage()               {}
-func (*Member) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{30} }
+func (*Member) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{35} }
 
 func (m *Member) GetID() uint64 {
 	if m != nil {
@@ -1894,7 +2096,7 @@ type MemberAddRequest struct {
 func (m *MemberAddRequest) Reset()                    { *m = MemberAddRequest{} }
 func (m *MemberAddRequest) String() string            { return proto.CompactTextString(m) }
 func (*MemberAddRequest) ProtoMessage()               {}
-func (*MemberAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{31} }
+func (*MemberAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{36} }
 
 func (m *MemberAddRequest) GetPeerURLs() []string {
 	if m != nil {
@@ -1914,7 +2116,7 @@ type MemberAddResponse struct {
 func (m *MemberAddResponse) Reset()                    { *m = MemberAddResponse{} }
 func (m *MemberAddResponse) String() string            { return proto.CompactTextString(m) }
 func (*MemberAddResponse) ProtoMessage()               {}
-func (*MemberAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{32} }
+func (*MemberAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{37} }
 
 func (m *MemberAddResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1945,7 +2147,7 @@ type MemberRemoveRequest struct {
 func (m *MemberRemoveRequest) Reset()                    { *m = MemberRemoveRequest{} }
 func (m *MemberRemoveRequest) String() string            { return proto.CompactTextString(m) }
 func (*MemberRemoveRequest) ProtoMessage()               {}
-func (*MemberRemoveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{33} }
+func (*MemberRemoveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{38} }
 
 func (m *MemberRemoveRequest) GetID() uint64 {
 	if m != nil {
@@ -1963,7 +2165,7 @@ type MemberRemoveResponse struct {
 func (m *MemberRemoveResponse) Reset()                    { *m = MemberRemoveResponse{} }
 func (m *MemberRemoveResponse) String() string            { return proto.CompactTextString(m) }
 func (*MemberRemoveResponse) ProtoMessage()               {}
-func (*MemberRemoveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{34} }
+func (*MemberRemoveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{39} }
 
 func (m *MemberRemoveResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1989,7 +2191,7 @@ type MemberUpdateRequest struct {
 func (m *MemberUpdateRequest) Reset()                    { *m = MemberUpdateRequest{} }
 func (m *MemberUpdateRequest) String() string            { return proto.CompactTextString(m) }
 func (*MemberUpdateRequest) ProtoMessage()               {}
-func (*MemberUpdateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{35} }
+func (*MemberUpdateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{40} }
 
 func (m *MemberUpdateRequest) GetID() uint64 {
 	if m != nil {
@@ -2014,7 +2216,7 @@ type MemberUpdateResponse struct {
 func (m *MemberUpdateResponse) Reset()                    { *m = MemberUpdateResponse{} }
 func (m *MemberUpdateResponse) String() string            { return proto.CompactTextString(m) }
 func (*MemberUpdateResponse) ProtoMessage()               {}
-func (*MemberUpdateResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{36} }
+func (*MemberUpdateResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{41} }
 
 func (m *MemberUpdateResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2036,7 +2238,7 @@ type MemberListRequest struct {
 func (m *MemberListRequest) Reset()                    { *m = MemberListRequest{} }
 func (m *MemberListRequest) String() string            { return proto.CompactTextString(m) }
 func (*MemberListRequest) ProtoMessage()               {}
-func (*MemberListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{37} }
+func (*MemberListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{42} }
 
 type MemberListResponse struct {
 	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
@@ -2047,7 +2249,7 @@ type MemberListResponse struct {
 func (m *MemberListResponse) Reset()                    { *m = MemberListResponse{} }
 func (m *MemberListResponse) String() string            { return proto.CompactTextString(m) }
 func (*MemberListResponse) ProtoMessage()               {}
-func (*MemberListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{38} }
+func (*MemberListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{43} }
 
 func (m *MemberListResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2069,7 +2271,7 @@ type DefragmentRequest struct {
 func (m *DefragmentRequest) Reset()                    { *m = DefragmentRequest{} }
 func (m *DefragmentRequest) String() string            { return proto.CompactTextString(m) }
 func (*DefragmentRequest) ProtoMessage()               {}
-func (*DefragmentRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{39} }
+func (*DefragmentRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{44} }
 
 type DefragmentResponse struct {
 	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
@@ -2078,7 +2280,7 @@ type DefragmentResponse struct {
 func (m *DefragmentResponse) Reset()                    { *m = DefragmentResponse{} }
 func (m *DefragmentResponse) String() string            { return proto.CompactTextString(m) }
 func (*DefragmentResponse) ProtoMessage()               {}
-func (*DefragmentResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{40} }
+func (*DefragmentResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{45} }
 
 func (m *DefragmentResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2087,6 +2289,39 @@ func (m *DefragmentResponse) GetHeader() *ResponseHeader {
 	return nil
 }
 
+type MoveLeaderRequest struct {
+	// targetID is the node ID for the new leader.
+	TargetID uint64 `protobuf:"varint,1,opt,name=targetID,proto3" json:"targetID,omitempty"`
+}
+
+func (m *MoveLeaderRequest) Reset()                    { *m = MoveLeaderRequest{} }
+func (m *MoveLeaderRequest) String() string            { return proto.CompactTextString(m) }
+func (*MoveLeaderRequest) ProtoMessage()               {}
+func (*MoveLeaderRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{46} }
+
+func (m *MoveLeaderRequest) GetTargetID() uint64 {
+	if m != nil {
+		return m.TargetID
+	}
+	return 0
+}
+
+type MoveLeaderResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *MoveLeaderResponse) Reset()                    { *m = MoveLeaderResponse{} }
+func (m *MoveLeaderResponse) String() string            { return proto.CompactTextString(m) }
+func (*MoveLeaderResponse) ProtoMessage()               {}
+func (*MoveLeaderResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{47} }
+
+func (m *MoveLeaderResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
 type AlarmRequest struct {
 	// action is the kind of alarm request to issue. The action
 	// may GET alarm statuses, ACTIVATE an alarm, or DEACTIVATE a
@@ -2102,7 +2337,7 @@ type AlarmRequest struct {
 func (m *AlarmRequest) Reset()                    { *m = AlarmRequest{} }
 func (m *AlarmRequest) String() string            { return proto.CompactTextString(m) }
 func (*AlarmRequest) ProtoMessage()               {}
-func (*AlarmRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{41} }
+func (*AlarmRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{48} }
 
 func (m *AlarmRequest) GetAction() AlarmRequest_AlarmAction {
 	if m != nil {
@@ -2135,7 +2370,7 @@ type AlarmMember struct {
 func (m *AlarmMember) Reset()                    { *m = AlarmMember{} }
 func (m *AlarmMember) String() string            { return proto.CompactTextString(m) }
 func (*AlarmMember) ProtoMessage()               {}
-func (*AlarmMember) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{42} }
+func (*AlarmMember) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{49} }
 
 func (m *AlarmMember) GetMemberID() uint64 {
 	if m != nil {
@@ -2160,7 +2395,7 @@ type AlarmResponse struct {
 func (m *AlarmResponse) Reset()                    { *m = AlarmResponse{} }
 func (m *AlarmResponse) String() string            { return proto.CompactTextString(m) }
 func (*AlarmResponse) ProtoMessage()               {}
-func (*AlarmResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{43} }
+func (*AlarmResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{50} }
 
 func (m *AlarmResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2182,7 +2417,7 @@ type StatusRequest struct {
 func (m *StatusRequest) Reset()                    { *m = StatusRequest{} }
 func (m *StatusRequest) String() string            { return proto.CompactTextString(m) }
 func (*StatusRequest) ProtoMessage()               {}
-func (*StatusRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{44} }
+func (*StatusRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{51} }
 
 type StatusResponse struct {
 	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
@@ -2201,7 +2436,7 @@ type StatusResponse struct {
 func (m *StatusResponse) Reset()                    { *m = StatusResponse{} }
 func (m *StatusResponse) String() string            { return proto.CompactTextString(m) }
 func (*StatusResponse) ProtoMessage()               {}
-func (*StatusResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{45} }
+func (*StatusResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{52} }
 
 func (m *StatusResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2251,7 +2486,7 @@ type AuthEnableRequest struct {
 func (m *AuthEnableRequest) Reset()                    { *m = AuthEnableRequest{} }
 func (m *AuthEnableRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthEnableRequest) ProtoMessage()               {}
-func (*AuthEnableRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{46} }
+func (*AuthEnableRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{53} }
 
 type AuthDisableRequest struct {
 }
@@ -2259,7 +2494,7 @@ type AuthDisableRequest struct {
 func (m *AuthDisableRequest) Reset()                    { *m = AuthDisableRequest{} }
 func (m *AuthDisableRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthDisableRequest) ProtoMessage()               {}
-func (*AuthDisableRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{47} }
+func (*AuthDisableRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{54} }
 
 type AuthenticateRequest struct {
 	Name     string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
@@ -2269,7 +2504,7 @@ type AuthenticateRequest struct {
 func (m *AuthenticateRequest) Reset()                    { *m = AuthenticateRequest{} }
 func (m *AuthenticateRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthenticateRequest) ProtoMessage()               {}
-func (*AuthenticateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{48} }
+func (*AuthenticateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{55} }
 
 func (m *AuthenticateRequest) GetName() string {
 	if m != nil {
@@ -2293,7 +2528,7 @@ type AuthUserAddRequest struct {
 func (m *AuthUserAddRequest) Reset()                    { *m = AuthUserAddRequest{} }
 func (m *AuthUserAddRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserAddRequest) ProtoMessage()               {}
-func (*AuthUserAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{49} }
+func (*AuthUserAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{56} }
 
 func (m *AuthUserAddRequest) GetName() string {
 	if m != nil {
@@ -2316,7 +2551,7 @@ type AuthUserGetRequest struct {
 func (m *AuthUserGetRequest) Reset()                    { *m = AuthUserGetRequest{} }
 func (m *AuthUserGetRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserGetRequest) ProtoMessage()               {}
-func (*AuthUserGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{50} }
+func (*AuthUserGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{57} }
 
 func (m *AuthUserGetRequest) GetName() string {
 	if m != nil {
@@ -2333,7 +2568,7 @@ type AuthUserDeleteRequest struct {
 func (m *AuthUserDeleteRequest) Reset()                    { *m = AuthUserDeleteRequest{} }
 func (m *AuthUserDeleteRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserDeleteRequest) ProtoMessage()               {}
-func (*AuthUserDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{51} }
+func (*AuthUserDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{58} }
 
 func (m *AuthUserDeleteRequest) GetName() string {
 	if m != nil {
@@ -2353,7 +2588,7 @@ func (m *AuthUserChangePasswordRequest) Reset()         { *m = AuthUserChangePas
 func (m *AuthUserChangePasswordRequest) String() string { return proto.CompactTextString(m) }
 func (*AuthUserChangePasswordRequest) ProtoMessage()    {}
 func (*AuthUserChangePasswordRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptorRpc, []int{52}
+	return fileDescriptorRpc, []int{59}
 }
 
 func (m *AuthUserChangePasswordRequest) GetName() string {
@@ -2380,7 +2615,7 @@ type AuthUserGrantRoleRequest struct {
 func (m *AuthUserGrantRoleRequest) Reset()                    { *m = AuthUserGrantRoleRequest{} }
 func (m *AuthUserGrantRoleRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserGrantRoleRequest) ProtoMessage()               {}
-func (*AuthUserGrantRoleRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{53} }
+func (*AuthUserGrantRoleRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{60} }
 
 func (m *AuthUserGrantRoleRequest) GetUser() string {
 	if m != nil {
@@ -2404,7 +2639,7 @@ type AuthUserRevokeRoleRequest struct {
 func (m *AuthUserRevokeRoleRequest) Reset()                    { *m = AuthUserRevokeRoleRequest{} }
 func (m *AuthUserRevokeRoleRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserRevokeRoleRequest) ProtoMessage()               {}
-func (*AuthUserRevokeRoleRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{54} }
+func (*AuthUserRevokeRoleRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{61} }
 
 func (m *AuthUserRevokeRoleRequest) GetName() string {
 	if m != nil {
@@ -2428,7 +2663,7 @@ type AuthRoleAddRequest struct {
 func (m *AuthRoleAddRequest) Reset()                    { *m = AuthRoleAddRequest{} }
 func (m *AuthRoleAddRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthRoleAddRequest) ProtoMessage()               {}
-func (*AuthRoleAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{55} }
+func (*AuthRoleAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{62} }
 
 func (m *AuthRoleAddRequest) GetName() string {
 	if m != nil {
@@ -2444,7 +2679,7 @@ type AuthRoleGetRequest struct {
 func (m *AuthRoleGetRequest) Reset()                    { *m = AuthRoleGetRequest{} }
 func (m *AuthRoleGetRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthRoleGetRequest) ProtoMessage()               {}
-func (*AuthRoleGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{56} }
+func (*AuthRoleGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{63} }
 
 func (m *AuthRoleGetRequest) GetRole() string {
 	if m != nil {
@@ -2459,7 +2694,7 @@ type AuthUserListRequest struct {
 func (m *AuthUserListRequest) Reset()                    { *m = AuthUserListRequest{} }
 func (m *AuthUserListRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserListRequest) ProtoMessage()               {}
-func (*AuthUserListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{57} }
+func (*AuthUserListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{64} }
 
 type AuthRoleListRequest struct {
 }
@@ -2467,7 +2702,7 @@ type AuthRoleListRequest struct {
 func (m *AuthRoleListRequest) Reset()                    { *m = AuthRoleListRequest{} }
 func (m *AuthRoleListRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthRoleListRequest) ProtoMessage()               {}
-func (*AuthRoleListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{58} }
+func (*AuthRoleListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{65} }
 
 type AuthRoleDeleteRequest struct {
 	Role string `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
@@ -2476,7 +2711,7 @@ type AuthRoleDeleteRequest struct {
 func (m *AuthRoleDeleteRequest) Reset()                    { *m = AuthRoleDeleteRequest{} }
 func (m *AuthRoleDeleteRequest) String() string            { return proto.CompactTextString(m) }
 func (*AuthRoleDeleteRequest) ProtoMessage()               {}
-func (*AuthRoleDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{59} }
+func (*AuthRoleDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{66} }
 
 func (m *AuthRoleDeleteRequest) GetRole() string {
 	if m != nil {
@@ -2496,7 +2731,7 @@ func (m *AuthRoleGrantPermissionRequest) Reset()         { *m = AuthRoleGrantPer
 func (m *AuthRoleGrantPermissionRequest) String() string { return proto.CompactTextString(m) }
 func (*AuthRoleGrantPermissionRequest) ProtoMessage()    {}
 func (*AuthRoleGrantPermissionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptorRpc, []int{60}
+	return fileDescriptorRpc, []int{67}
 }
 
 func (m *AuthRoleGrantPermissionRequest) GetName() string {
@@ -2523,7 +2758,7 @@ func (m *AuthRoleRevokePermissionRequest) Reset()         { *m = AuthRoleRevokeP
 func (m *AuthRoleRevokePermissionRequest) String() string { return proto.CompactTextString(m) }
 func (*AuthRoleRevokePermissionRequest) ProtoMessage()    {}
 func (*AuthRoleRevokePermissionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptorRpc, []int{61}
+	return fileDescriptorRpc, []int{68}
 }
 
 func (m *AuthRoleRevokePermissionRequest) GetRole() string {
@@ -2554,7 +2789,7 @@ type AuthEnableResponse struct {
 func (m *AuthEnableResponse) Reset()                    { *m = AuthEnableResponse{} }
 func (m *AuthEnableResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthEnableResponse) ProtoMessage()               {}
-func (*AuthEnableResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{62} }
+func (*AuthEnableResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{69} }
 
 func (m *AuthEnableResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2570,7 +2805,7 @@ type AuthDisableResponse struct {
 func (m *AuthDisableResponse) Reset()                    { *m = AuthDisableResponse{} }
 func (m *AuthDisableResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthDisableResponse) ProtoMessage()               {}
-func (*AuthDisableResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{63} }
+func (*AuthDisableResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{70} }
 
 func (m *AuthDisableResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2588,7 +2823,7 @@ type AuthenticateResponse struct {
 func (m *AuthenticateResponse) Reset()                    { *m = AuthenticateResponse{} }
 func (m *AuthenticateResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthenticateResponse) ProtoMessage()               {}
-func (*AuthenticateResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{64} }
+func (*AuthenticateResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{71} }
 
 func (m *AuthenticateResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2611,7 +2846,7 @@ type AuthUserAddResponse struct {
 func (m *AuthUserAddResponse) Reset()                    { *m = AuthUserAddResponse{} }
 func (m *AuthUserAddResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserAddResponse) ProtoMessage()               {}
-func (*AuthUserAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{65} }
+func (*AuthUserAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{72} }
 
 func (m *AuthUserAddResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2628,7 +2863,7 @@ type AuthUserGetResponse struct {
 func (m *AuthUserGetResponse) Reset()                    { *m = AuthUserGetResponse{} }
 func (m *AuthUserGetResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserGetResponse) ProtoMessage()               {}
-func (*AuthUserGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{66} }
+func (*AuthUserGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{73} }
 
 func (m *AuthUserGetResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2651,7 +2886,7 @@ type AuthUserDeleteResponse struct {
 func (m *AuthUserDeleteResponse) Reset()                    { *m = AuthUserDeleteResponse{} }
 func (m *AuthUserDeleteResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserDeleteResponse) ProtoMessage()               {}
-func (*AuthUserDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{67} }
+func (*AuthUserDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{74} }
 
 func (m *AuthUserDeleteResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2668,7 +2903,7 @@ func (m *AuthUserChangePasswordResponse) Reset()         { *m = AuthUserChangePa
 func (m *AuthUserChangePasswordResponse) String() string { return proto.CompactTextString(m) }
 func (*AuthUserChangePasswordResponse) ProtoMessage()    {}
 func (*AuthUserChangePasswordResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptorRpc, []int{68}
+	return fileDescriptorRpc, []int{75}
 }
 
 func (m *AuthUserChangePasswordResponse) GetHeader() *ResponseHeader {
@@ -2685,7 +2920,7 @@ type AuthUserGrantRoleResponse struct {
 func (m *AuthUserGrantRoleResponse) Reset()                    { *m = AuthUserGrantRoleResponse{} }
 func (m *AuthUserGrantRoleResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserGrantRoleResponse) ProtoMessage()               {}
-func (*AuthUserGrantRoleResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{69} }
+func (*AuthUserGrantRoleResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{76} }
 
 func (m *AuthUserGrantRoleResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2701,7 +2936,7 @@ type AuthUserRevokeRoleResponse struct {
 func (m *AuthUserRevokeRoleResponse) Reset()                    { *m = AuthUserRevokeRoleResponse{} }
 func (m *AuthUserRevokeRoleResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserRevokeRoleResponse) ProtoMessage()               {}
-func (*AuthUserRevokeRoleResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{70} }
+func (*AuthUserRevokeRoleResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{77} }
 
 func (m *AuthUserRevokeRoleResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2717,7 +2952,7 @@ type AuthRoleAddResponse struct {
 func (m *AuthRoleAddResponse) Reset()                    { *m = AuthRoleAddResponse{} }
 func (m *AuthRoleAddResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthRoleAddResponse) ProtoMessage()               {}
-func (*AuthRoleAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{71} }
+func (*AuthRoleAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{78} }
 
 func (m *AuthRoleAddResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2734,7 +2969,7 @@ type AuthRoleGetResponse struct {
 func (m *AuthRoleGetResponse) Reset()                    { *m = AuthRoleGetResponse{} }
 func (m *AuthRoleGetResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthRoleGetResponse) ProtoMessage()               {}
-func (*AuthRoleGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{72} }
+func (*AuthRoleGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{79} }
 
 func (m *AuthRoleGetResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2758,7 +2993,7 @@ type AuthRoleListResponse struct {
 func (m *AuthRoleListResponse) Reset()                    { *m = AuthRoleListResponse{} }
 func (m *AuthRoleListResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthRoleListResponse) ProtoMessage()               {}
-func (*AuthRoleListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{73} }
+func (*AuthRoleListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{80} }
 
 func (m *AuthRoleListResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2782,7 +3017,7 @@ type AuthUserListResponse struct {
 func (m *AuthUserListResponse) Reset()                    { *m = AuthUserListResponse{} }
 func (m *AuthUserListResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthUserListResponse) ProtoMessage()               {}
-func (*AuthUserListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{74} }
+func (*AuthUserListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{81} }
 
 func (m *AuthUserListResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2805,7 +3040,7 @@ type AuthRoleDeleteResponse struct {
 func (m *AuthRoleDeleteResponse) Reset()                    { *m = AuthRoleDeleteResponse{} }
 func (m *AuthRoleDeleteResponse) String() string            { return proto.CompactTextString(m) }
 func (*AuthRoleDeleteResponse) ProtoMessage()               {}
-func (*AuthRoleDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{75} }
+func (*AuthRoleDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{82} }
 
 func (m *AuthRoleDeleteResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -2822,7 +3057,7 @@ func (m *AuthRoleGrantPermissionResponse) Reset()         { *m = AuthRoleGrantPe
 func (m *AuthRoleGrantPermissionResponse) String() string { return proto.CompactTextString(m) }
 func (*AuthRoleGrantPermissionResponse) ProtoMessage()    {}
 func (*AuthRoleGrantPermissionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptorRpc, []int{76}
+	return fileDescriptorRpc, []int{83}
 }
 
 func (m *AuthRoleGrantPermissionResponse) GetHeader() *ResponseHeader {
@@ -2840,7 +3075,7 @@ func (m *AuthRoleRevokePermissionResponse) Reset()         { *m = AuthRoleRevoke
 func (m *AuthRoleRevokePermissionResponse) String() string { return proto.CompactTextString(m) }
 func (*AuthRoleRevokePermissionResponse) ProtoMessage()    {}
 func (*AuthRoleRevokePermissionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptorRpc, []int{77}
+	return fileDescriptorRpc, []int{84}
 }
 
 func (m *AuthRoleRevokePermissionResponse) GetHeader() *ResponseHeader {
@@ -2866,6 +3101,8 @@ func init() {
 	proto.RegisterType((*CompactionRequest)(nil), "etcdserverpb.CompactionRequest")
 	proto.RegisterType((*CompactionResponse)(nil), "etcdserverpb.CompactionResponse")
 	proto.RegisterType((*HashRequest)(nil), "etcdserverpb.HashRequest")
+	proto.RegisterType((*HashKVRequest)(nil), "etcdserverpb.HashKVRequest")
+	proto.RegisterType((*HashKVResponse)(nil), "etcdserverpb.HashKVResponse")
 	proto.RegisterType((*HashResponse)(nil), "etcdserverpb.HashResponse")
 	proto.RegisterType((*SnapshotRequest)(nil), "etcdserverpb.SnapshotRequest")
 	proto.RegisterType((*SnapshotResponse)(nil), "etcdserverpb.SnapshotResponse")
@@ -2881,6 +3118,9 @@ func init() {
 	proto.RegisterType((*LeaseKeepAliveResponse)(nil), "etcdserverpb.LeaseKeepAliveResponse")
 	proto.RegisterType((*LeaseTimeToLiveRequest)(nil), "etcdserverpb.LeaseTimeToLiveRequest")
 	proto.RegisterType((*LeaseTimeToLiveResponse)(nil), "etcdserverpb.LeaseTimeToLiveResponse")
+	proto.RegisterType((*LeaseLeasesRequest)(nil), "etcdserverpb.LeaseLeasesRequest")
+	proto.RegisterType((*LeaseStatus)(nil), "etcdserverpb.LeaseStatus")
+	proto.RegisterType((*LeaseLeasesResponse)(nil), "etcdserverpb.LeaseLeasesResponse")
 	proto.RegisterType((*Member)(nil), "etcdserverpb.Member")
 	proto.RegisterType((*MemberAddRequest)(nil), "etcdserverpb.MemberAddRequest")
 	proto.RegisterType((*MemberAddResponse)(nil), "etcdserverpb.MemberAddResponse")
@@ -2892,6 +3132,8 @@ func init() {
 	proto.RegisterType((*MemberListResponse)(nil), "etcdserverpb.MemberListResponse")
 	proto.RegisterType((*DefragmentRequest)(nil), "etcdserverpb.DefragmentRequest")
 	proto.RegisterType((*DefragmentResponse)(nil), "etcdserverpb.DefragmentResponse")
+	proto.RegisterType((*MoveLeaderRequest)(nil), "etcdserverpb.MoveLeaderRequest")
+	proto.RegisterType((*MoveLeaderResponse)(nil), "etcdserverpb.MoveLeaderResponse")
 	proto.RegisterType((*AlarmRequest)(nil), "etcdserverpb.AlarmRequest")
 	proto.RegisterType((*AlarmMember)(nil), "etcdserverpb.AlarmMember")
 	proto.RegisterType((*AlarmResponse)(nil), "etcdserverpb.AlarmResponse")
@@ -3290,6 +3532,8 @@ type LeaseClient interface {
 	LeaseKeepAlive(ctx context.Context, opts ...grpc.CallOption) (Lease_LeaseKeepAliveClient, error)
 	// LeaseTimeToLive retrieves lease information.
 	LeaseTimeToLive(ctx context.Context, in *LeaseTimeToLiveRequest, opts ...grpc.CallOption) (*LeaseTimeToLiveResponse, error)
+	// LeaseLeases lists all existing leases.
+	LeaseLeases(ctx context.Context, in *LeaseLeasesRequest, opts ...grpc.CallOption) (*LeaseLeasesResponse, error)
 }
 
 type leaseClient struct {
@@ -3358,6 +3602,15 @@ func (c *leaseClient) LeaseTimeToLive(ctx context.Context, in *LeaseTimeToLiveRe
 	return out, nil
 }
 
+func (c *leaseClient) LeaseLeases(ctx context.Context, in *LeaseLeasesRequest, opts ...grpc.CallOption) (*LeaseLeasesResponse, error) {
+	out := new(LeaseLeasesResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Lease/LeaseLeases", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for Lease service
 
 type LeaseServer interface {
@@ -3372,6 +3625,8 @@ type LeaseServer interface {
 	LeaseKeepAlive(Lease_LeaseKeepAliveServer) error
 	// LeaseTimeToLive retrieves lease information.
 	LeaseTimeToLive(context.Context, *LeaseTimeToLiveRequest) (*LeaseTimeToLiveResponse, error)
+	// LeaseLeases lists all existing leases.
+	LeaseLeases(context.Context, *LeaseLeasesRequest) (*LeaseLeasesResponse, error)
 }
 
 func RegisterLeaseServer(s *grpc.Server, srv LeaseServer) {
@@ -3458,6 +3713,24 @@ func _Lease_LeaseTimeToLive_Handler(srv interface{}, ctx context.Context, dec fu
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Lease_LeaseLeases_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(LeaseLeasesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LeaseServer).LeaseLeases(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Lease/LeaseLeases",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LeaseServer).LeaseLeases(ctx, req.(*LeaseLeasesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Lease_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "etcdserverpb.Lease",
 	HandlerType: (*LeaseServer)(nil),
@@ -3474,6 +3747,10 @@ var _Lease_serviceDesc = grpc.ServiceDesc{
 			MethodName: "LeaseTimeToLive",
 			Handler:    _Lease_LeaseTimeToLive_Handler,
 		},
+		{
+			MethodName: "LeaseLeases",
+			Handler:    _Lease_LeaseLeases_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -3666,12 +3943,16 @@ type MaintenanceClient interface {
 	Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error)
 	// Defragment defragments a member's backend database to recover storage space.
 	Defragment(ctx context.Context, in *DefragmentRequest, opts ...grpc.CallOption) (*DefragmentResponse, error)
-	// Hash returns the hash of the local KV state for consistency checking purpose.
+	// Hash computes the hash of the KV's backend.
 	// This is designed for testing; do not use this in production when there
 	// are ongoing transactions.
 	Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error)
+	// HashKV computes the hash of all MVCC keys up to a given revision.
+	HashKV(ctx context.Context, in *HashKVRequest, opts ...grpc.CallOption) (*HashKVResponse, error)
 	// Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
 	Snapshot(ctx context.Context, in *SnapshotRequest, opts ...grpc.CallOption) (Maintenance_SnapshotClient, error)
+	// MoveLeader requests current leader node to transfer its leadership to transferee.
+	MoveLeader(ctx context.Context, in *MoveLeaderRequest, opts ...grpc.CallOption) (*MoveLeaderResponse, error)
 }
 
 type maintenanceClient struct {
@@ -3718,6 +3999,15 @@ func (c *maintenanceClient) Hash(ctx context.Context, in *HashRequest, opts ...g
 	return out, nil
 }
 
+func (c *maintenanceClient) HashKV(ctx context.Context, in *HashKVRequest, opts ...grpc.CallOption) (*HashKVResponse, error) {
+	out := new(HashKVResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/HashKV", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *maintenanceClient) Snapshot(ctx context.Context, in *SnapshotRequest, opts ...grpc.CallOption) (Maintenance_SnapshotClient, error) {
 	stream, err := grpc.NewClientStream(ctx, &_Maintenance_serviceDesc.Streams[0], c.cc, "/etcdserverpb.Maintenance/Snapshot", opts...)
 	if err != nil {
@@ -3750,6 +4040,15 @@ func (x *maintenanceSnapshotClient) Recv() (*SnapshotResponse, error) {
 	return m, nil
 }
 
+func (c *maintenanceClient) MoveLeader(ctx context.Context, in *MoveLeaderRequest, opts ...grpc.CallOption) (*MoveLeaderResponse, error) {
+	out := new(MoveLeaderResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/MoveLeader", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for Maintenance service
 
 type MaintenanceServer interface {
@@ -3759,12 +4058,16 @@ type MaintenanceServer interface {
 	Status(context.Context, *StatusRequest) (*StatusResponse, error)
 	// Defragment defragments a member's backend database to recover storage space.
 	Defragment(context.Context, *DefragmentRequest) (*DefragmentResponse, error)
-	// Hash returns the hash of the local KV state for consistency checking purpose.
+	// Hash computes the hash of the KV's backend.
 	// This is designed for testing; do not use this in production when there
 	// are ongoing transactions.
 	Hash(context.Context, *HashRequest) (*HashResponse, error)
+	// HashKV computes the hash of all MVCC keys up to a given revision.
+	HashKV(context.Context, *HashKVRequest) (*HashKVResponse, error)
 	// Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
 	Snapshot(*SnapshotRequest, Maintenance_SnapshotServer) error
+	// MoveLeader requests current leader node to transfer its leadership to transferee.
+	MoveLeader(context.Context, *MoveLeaderRequest) (*MoveLeaderResponse, error)
 }
 
 func RegisterMaintenanceServer(s *grpc.Server, srv MaintenanceServer) {
@@ -3843,6 +4146,24 @@ func _Maintenance_Hash_Handler(srv interface{}, ctx context.Context, dec func(in
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Maintenance_HashKV_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(HashKVRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MaintenanceServer).HashKV(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Maintenance/HashKV",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MaintenanceServer).HashKV(ctx, req.(*HashKVRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Maintenance_Snapshot_Handler(srv interface{}, stream grpc.ServerStream) error {
 	m := new(SnapshotRequest)
 	if err := stream.RecvMsg(m); err != nil {
@@ -3864,6 +4185,24 @@ func (x *maintenanceSnapshotServer) Send(m *SnapshotResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
+func _Maintenance_MoveLeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MoveLeaderRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MaintenanceServer).MoveLeader(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Maintenance/MoveLeader",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MaintenanceServer).MoveLeader(ctx, req.(*MoveLeaderRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Maintenance_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "etcdserverpb.Maintenance",
 	HandlerType: (*MaintenanceServer)(nil),
@@ -3884,6 +4223,14 @@ var _Maintenance_serviceDesc = grpc.ServiceDesc{
 			MethodName: "Hash",
 			Handler:    _Maintenance_Hash_Handler,
 		},
+		{
+			MethodName: "HashKV",
+			Handler:    _Maintenance_HashKV_Handler,
+		},
+		{
+			MethodName: "MoveLeader",
+			Handler:    _Maintenance_MoveLeader_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -4934,6 +5281,20 @@ func (m *RequestOp_RequestDeleteRange) MarshalTo(dAtA []byte) (int, error) {
 	}
 	return i, nil
 }
+func (m *RequestOp_RequestTxn) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.RequestTxn != nil {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.RequestTxn.Size()))
+		n9, err := m.RequestTxn.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n9
+	}
+	return i, nil
+}
 func (m *ResponseOp) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -4950,11 +5311,11 @@ func (m *ResponseOp) MarshalTo(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if m.Response != nil {
-		nn9, err := m.Response.MarshalTo(dAtA[i:])
+		nn10, err := m.Response.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += nn9
+		i += nn10
 	}
 	return i, nil
 }
@@ -4965,11 +5326,11 @@ func (m *ResponseOp_ResponseRange) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.ResponseRange.Size()))
-		n10, err := m.ResponseRange.MarshalTo(dAtA[i:])
+		n11, err := m.ResponseRange.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n10
+		i += n11
 	}
 	return i, nil
 }
@@ -4979,11 +5340,11 @@ func (m *ResponseOp_ResponsePut) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.ResponsePut.Size()))
-		n11, err := m.ResponsePut.MarshalTo(dAtA[i:])
+		n12, err := m.ResponsePut.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n11
+		i += n12
 	}
 	return i, nil
 }
@@ -4993,11 +5354,25 @@ func (m *ResponseOp_ResponseDeleteRange) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x1a
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.ResponseDeleteRange.Size()))
-		n12, err := m.ResponseDeleteRange.MarshalTo(dAtA[i:])
+		n13, err := m.ResponseDeleteRange.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n12
+		i += n13
+	}
+	return i, nil
+}
+func (m *ResponseOp_ResponseTxn) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.ResponseTxn != nil {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ResponseTxn.Size()))
+		n14, err := m.ResponseTxn.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n14
 	}
 	return i, nil
 }
@@ -5033,11 +5408,19 @@ func (m *Compare) MarshalTo(dAtA []byte) (int, error) {
 		i += copy(dAtA[i:], m.Key)
 	}
 	if m.TargetUnion != nil {
-		nn13, err := m.TargetUnion.MarshalTo(dAtA[i:])
+		nn15, err := m.TargetUnion.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += nn13
+		i += nn15
+	}
+	if len(m.RangeEnd) > 0 {
+		dAtA[i] = 0x82
+		i++
+		dAtA[i] = 0x4
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
+		i += copy(dAtA[i:], m.RangeEnd)
 	}
 	return i, nil
 }
@@ -5073,6 +5456,13 @@ func (m *Compare_Value) MarshalTo(dAtA []byte) (int, error) {
 	}
 	return i, nil
 }
+func (m *Compare_Lease) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	dAtA[i] = 0x40
+	i++
+	i = encodeVarintRpc(dAtA, i, uint64(m.Lease))
+	return i, nil
+}
 func (m *TxnRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -5146,11 +5536,11 @@ func (m *TxnResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n14, err := m.Header.MarshalTo(dAtA[i:])
+		n16, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n14
+		i += n16
 	}
 	if m.Succeeded {
 		dAtA[i] = 0x10
@@ -5229,11 +5619,11 @@ func (m *CompactionResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n15, err := m.Header.MarshalTo(dAtA[i:])
+		n17, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n15
+		i += n17
 	}
 	return i, nil
 }
@@ -5256,6 +5646,67 @@ func (m *HashRequest) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
+func (m *HashKVRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *HashKVRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Revision != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Revision))
+	}
+	return i, nil
+}
+
+func (m *HashKVResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *HashKVResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n18, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n18
+	}
+	if m.Hash != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Hash))
+	}
+	if m.CompactRevision != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.CompactRevision))
+	}
+	return i, nil
+}
+
 func (m *HashResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -5275,11 +5726,11 @@ func (m *HashResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n16, err := m.Header.MarshalTo(dAtA[i:])
+		n19, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n16
+		i += n19
 	}
 	if m.Hash != 0 {
 		dAtA[i] = 0x10
@@ -5326,11 +5777,11 @@ func (m *SnapshotResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n17, err := m.Header.MarshalTo(dAtA[i:])
+		n20, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n17
+		i += n20
 	}
 	if m.RemainingBytes != 0 {
 		dAtA[i] = 0x10
@@ -5362,11 +5813,11 @@ func (m *WatchRequest) MarshalTo(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if m.RequestUnion != nil {
-		nn18, err := m.RequestUnion.MarshalTo(dAtA[i:])
+		nn21, err := m.RequestUnion.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += nn18
+		i += nn21
 	}
 	return i, nil
 }
@@ -5377,11 +5828,11 @@ func (m *WatchRequest_CreateRequest) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.CreateRequest.Size()))
-		n19, err := m.CreateRequest.MarshalTo(dAtA[i:])
+		n22, err := m.CreateRequest.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n19
+		i += n22
 	}
 	return i, nil
 }
@@ -5391,11 +5842,11 @@ func (m *WatchRequest_CancelRequest) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.CancelRequest.Size()))
-		n20, err := m.CancelRequest.MarshalTo(dAtA[i:])
+		n23, err := m.CancelRequest.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n20
+		i += n23
 	}
 	return i, nil
 }
@@ -5442,21 +5893,21 @@ func (m *WatchCreateRequest) MarshalTo(dAtA []byte) (int, error) {
 		i++
 	}
 	if len(m.Filters) > 0 {
-		dAtA22 := make([]byte, len(m.Filters)*10)
-		var j21 int
+		dAtA25 := make([]byte, len(m.Filters)*10)
+		var j24 int
 		for _, num := range m.Filters {
 			for num >= 1<<7 {
-				dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j21++
+				j24++
 			}
-			dAtA22[j21] = uint8(num)
-			j21++
+			dAtA25[j24] = uint8(num)
+			j24++
 		}
 		dAtA[i] = 0x2a
 		i++
-		i = encodeVarintRpc(dAtA, i, uint64(j21))
-		i += copy(dAtA[i:], dAtA22[:j21])
+		i = encodeVarintRpc(dAtA, i, uint64(j24))
+		i += copy(dAtA[i:], dAtA25[:j24])
 	}
 	if m.PrevKv {
 		dAtA[i] = 0x30
@@ -5513,11 +5964,11 @@ func (m *WatchResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n23, err := m.Header.MarshalTo(dAtA[i:])
+		n26, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n23
+		i += n26
 	}
 	if m.WatchId != 0 {
 		dAtA[i] = 0x10
@@ -5617,11 +6068,11 @@ func (m *LeaseGrantResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n24, err := m.Header.MarshalTo(dAtA[i:])
+		n27, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n24
+		i += n27
 	}
 	if m.ID != 0 {
 		dAtA[i] = 0x10
@@ -5684,11 +6135,11 @@ func (m *LeaseRevokeResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n25, err := m.Header.MarshalTo(dAtA[i:])
+		n28, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n25
+		i += n28
 	}
 	return i, nil
 }
@@ -5735,11 +6186,11 @@ func (m *LeaseKeepAliveResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n26, err := m.Header.MarshalTo(dAtA[i:])
+		n29, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n26
+		i += n29
 	}
 	if m.ID != 0 {
 		dAtA[i] = 0x10
@@ -5806,11 +6257,11 @@ func (m *LeaseTimeToLiveResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n27, err := m.Header.MarshalTo(dAtA[i:])
+		n30, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n27
+		i += n30
 	}
 	if m.ID != 0 {
 		dAtA[i] = 0x10
@@ -5838,6 +6289,87 @@ func (m *LeaseTimeToLiveResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
+func (m *LeaseLeasesRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseLeasesRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *LeaseStatus) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseStatus) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	return i, nil
+}
+
+func (m *LeaseLeasesResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseLeasesResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n31, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n31
+	}
+	if len(m.Leases) > 0 {
+		for _, msg := range m.Leases {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
 func (m *Member) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -5949,21 +6481,21 @@ func (m *MemberAddResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n28, err := m.Header.MarshalTo(dAtA[i:])
+		n32, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n28
+		i += n32
 	}
 	if m.Member != nil {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Member.Size()))
-		n29, err := m.Member.MarshalTo(dAtA[i:])
+		n33, err := m.Member.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n29
+		i += n33
 	}
 	if len(m.Members) > 0 {
 		for _, msg := range m.Members {
@@ -6022,11 +6554,11 @@ func (m *MemberRemoveResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n30, err := m.Header.MarshalTo(dAtA[i:])
+		n34, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n30
+		i += n34
 	}
 	if len(m.Members) > 0 {
 		for _, msg := range m.Members {
@@ -6100,11 +6632,11 @@ func (m *MemberUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n31, err := m.Header.MarshalTo(dAtA[i:])
+		n35, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n31
+		i += n35
 	}
 	if len(m.Members) > 0 {
 		for _, msg := range m.Members {
@@ -6158,11 +6690,11 @@ func (m *MemberListResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n32, err := m.Header.MarshalTo(dAtA[i:])
+		n36, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n32
+		i += n36
 	}
 	if len(m.Members) > 0 {
 		for _, msg := range m.Members {
@@ -6216,11 +6748,62 @@ func (m *DefragmentResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n33, err := m.Header.MarshalTo(dAtA[i:])
+		n37, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n33
+		i += n37
+	}
+	return i, nil
+}
+
+func (m *MoveLeaderRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MoveLeaderRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.TargetID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.TargetID))
+	}
+	return i, nil
+}
+
+func (m *MoveLeaderResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MoveLeaderResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n38, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n38
 	}
 	return i, nil
 }
@@ -6305,11 +6888,11 @@ func (m *AlarmResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n34, err := m.Header.MarshalTo(dAtA[i:])
+		n39, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n34
+		i += n39
 	}
 	if len(m.Alarms) > 0 {
 		for _, msg := range m.Alarms {
@@ -6363,11 +6946,11 @@ func (m *StatusResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n35, err := m.Header.MarshalTo(dAtA[i:])
+		n40, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n35
+		i += n40
 	}
 	if len(m.Version) > 0 {
 		dAtA[i] = 0x12
@@ -6765,11 +7348,11 @@ func (m *AuthRoleGrantPermissionRequest) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Perm.Size()))
-		n36, err := m.Perm.MarshalTo(dAtA[i:])
+		n41, err := m.Perm.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n36
+		i += n41
 	}
 	return i, nil
 }
@@ -6829,11 +7412,11 @@ func (m *AuthEnableResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n37, err := m.Header.MarshalTo(dAtA[i:])
+		n42, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n37
+		i += n42
 	}
 	return i, nil
 }
@@ -6857,11 +7440,11 @@ func (m *AuthDisableResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n38, err := m.Header.MarshalTo(dAtA[i:])
+		n43, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n38
+		i += n43
 	}
 	return i, nil
 }
@@ -6885,11 +7468,11 @@ func (m *AuthenticateResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n39, err := m.Header.MarshalTo(dAtA[i:])
+		n44, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n39
+		i += n44
 	}
 	if len(m.Token) > 0 {
 		dAtA[i] = 0x12
@@ -6919,11 +7502,11 @@ func (m *AuthUserAddResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n40, err := m.Header.MarshalTo(dAtA[i:])
+		n45, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n40
+		i += n45
 	}
 	return i, nil
 }
@@ -6947,11 +7530,11 @@ func (m *AuthUserGetResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n41, err := m.Header.MarshalTo(dAtA[i:])
+		n46, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n41
+		i += n46
 	}
 	if len(m.Roles) > 0 {
 		for _, s := range m.Roles {
@@ -6990,11 +7573,11 @@ func (m *AuthUserDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n42, err := m.Header.MarshalTo(dAtA[i:])
+		n47, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n42
+		i += n47
 	}
 	return i, nil
 }
@@ -7018,11 +7601,11 @@ func (m *AuthUserChangePasswordResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n43, err := m.Header.MarshalTo(dAtA[i:])
+		n48, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n43
+		i += n48
 	}
 	return i, nil
 }
@@ -7046,11 +7629,11 @@ func (m *AuthUserGrantRoleResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n44, err := m.Header.MarshalTo(dAtA[i:])
+		n49, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n44
+		i += n49
 	}
 	return i, nil
 }
@@ -7074,11 +7657,11 @@ func (m *AuthUserRevokeRoleResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n45, err := m.Header.MarshalTo(dAtA[i:])
+		n50, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n45
+		i += n50
 	}
 	return i, nil
 }
@@ -7102,11 +7685,11 @@ func (m *AuthRoleAddResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n46, err := m.Header.MarshalTo(dAtA[i:])
+		n51, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n46
+		i += n51
 	}
 	return i, nil
 }
@@ -7130,11 +7713,11 @@ func (m *AuthRoleGetResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n47, err := m.Header.MarshalTo(dAtA[i:])
+		n52, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n47
+		i += n52
 	}
 	if len(m.Perm) > 0 {
 		for _, msg := range m.Perm {
@@ -7170,11 +7753,11 @@ func (m *AuthRoleListResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n48, err := m.Header.MarshalTo(dAtA[i:])
+		n53, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n48
+		i += n53
 	}
 	if len(m.Roles) > 0 {
 		for _, s := range m.Roles {
@@ -7213,11 +7796,11 @@ func (m *AuthUserListResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n49, err := m.Header.MarshalTo(dAtA[i:])
+		n54, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n49
+		i += n54
 	}
 	if len(m.Users) > 0 {
 		for _, s := range m.Users {
@@ -7256,11 +7839,11 @@ func (m *AuthRoleDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n50, err := m.Header.MarshalTo(dAtA[i:])
+		n55, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n50
+		i += n55
 	}
 	return i, nil
 }
@@ -7284,11 +7867,11 @@ func (m *AuthRoleGrantPermissionResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n51, err := m.Header.MarshalTo(dAtA[i:])
+		n56, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n51
+		i += n56
 	}
 	return i, nil
 }
@@ -7312,33 +7895,15 @@ func (m *AuthRoleRevokePermissionResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
-		n52, err := m.Header.MarshalTo(dAtA[i:])
+		n57, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n52
+		i += n57
 	}
 	return i, nil
 }
 
-func encodeFixed64Rpc(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Rpc(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintRpc(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -7547,6 +8112,15 @@ func (m *RequestOp_RequestDeleteRange) Size() (n int) {
 	}
 	return n
 }
+func (m *RequestOp_RequestTxn) Size() (n int) {
+	var l int
+	_ = l
+	if m.RequestTxn != nil {
+		l = m.RequestTxn.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
 func (m *ResponseOp) Size() (n int) {
 	var l int
 	_ = l
@@ -7583,6 +8157,15 @@ func (m *ResponseOp_ResponseDeleteRange) Size() (n int) {
 	}
 	return n
 }
+func (m *ResponseOp_ResponseTxn) Size() (n int) {
+	var l int
+	_ = l
+	if m.ResponseTxn != nil {
+		l = m.ResponseTxn.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
 func (m *Compare) Size() (n int) {
 	var l int
 	_ = l
@@ -7599,6 +8182,10 @@ func (m *Compare) Size() (n int) {
 	if m.TargetUnion != nil {
 		n += m.TargetUnion.Size()
 	}
+	l = len(m.RangeEnd)
+	if l > 0 {
+		n += 2 + l + sovRpc(uint64(l))
+	}
 	return n
 }
 
@@ -7629,6 +8216,12 @@ func (m *Compare_Value) Size() (n int) {
 	}
 	return n
 }
+func (m *Compare_Lease) Size() (n int) {
+	var l int
+	_ = l
+	n += 1 + sovRpc(uint64(m.Lease))
+	return n
+}
 func (m *TxnRequest) Size() (n int) {
 	var l int
 	_ = l
@@ -7700,6 +8293,31 @@ func (m *HashRequest) Size() (n int) {
 	return n
 }
 
+func (m *HashKVRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Revision != 0 {
+		n += 1 + sovRpc(uint64(m.Revision))
+	}
+	return n
+}
+
+func (m *HashKVResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.Hash != 0 {
+		n += 1 + sovRpc(uint64(m.Hash))
+	}
+	if m.CompactRevision != 0 {
+		n += 1 + sovRpc(uint64(m.CompactRevision))
+	}
+	return n
+}
+
 func (m *HashResponse) Size() (n int) {
 	var l int
 	_ = l
@@ -7947,6 +8565,37 @@ func (m *LeaseTimeToLiveResponse) Size() (n int) {
 	return n
 }
 
+func (m *LeaseLeasesRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *LeaseStatus) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	return n
+}
+
+func (m *LeaseLeasesResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Leases) > 0 {
+		for _, e := range m.Leases {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
 func (m *Member) Size() (n int) {
 	var l int
 	_ = l
@@ -8098,6 +8747,25 @@ func (m *DefragmentResponse) Size() (n int) {
 	return n
 }
 
+func (m *MoveLeaderRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.TargetID != 0 {
+		n += 1 + sovRpc(uint64(m.TargetID))
+	}
+	return n
+}
+
+func (m *MoveLeaderResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
 func (m *AlarmRequest) Size() (n int) {
 	var l int
 	_ = l
@@ -9850,6 +10518,38 @@ func (m *RequestOp) Unmarshal(dAtA []byte) error {
 			}
 			m.Request = &RequestOp_RequestDeleteRange{v}
 			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RequestTxn", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &TxnRequest{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Request = &RequestOp_RequestTxn{v}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipRpc(dAtA[iNdEx:])
@@ -9996,6 +10696,38 @@ func (m *ResponseOp) Unmarshal(dAtA []byte) error {
 			}
 			m.Response = &ResponseOp_ResponseDeleteRange{v}
 			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ResponseTxn", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &TxnResponse{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Response = &ResponseOp_ResponseTxn{v}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipRpc(dAtA[iNdEx:])
@@ -10205,6 +10937,57 @@ func (m *Compare) Unmarshal(dAtA []byte) error {
 			copy(v, dAtA[iNdEx:postIndex])
 			m.TargetUnion = &Compare_Value{v}
 			iNdEx = postIndex
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType)
+			}
+			var v int64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.TargetUnion = &Compare_Lease{v}
+		case 64:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
+			if m.RangeEnd == nil {
+				m.RangeEnd = []byte{}
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipRpc(dAtA[iNdEx:])
@@ -10725,6 +11508,196 @@ func (m *HashRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *HashKVRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: HashKVRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: HashKVRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
+			}
+			m.Revision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Revision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *HashKVResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: HashKVResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: HashKVResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
+			}
+			m.Hash = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Hash |= (uint32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CompactRevision", wireType)
+			}
+			m.CompactRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CompactRevision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *HashResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -12485,6 +13458,239 @@ func (m *LeaseTimeToLiveResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *LeaseLeasesRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseLeasesRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseLeasesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseStatus) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseStatus: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseLeasesResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseLeasesResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseLeasesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Leases", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Leases = append(m.Leases, &LeaseStatus{})
+			if err := m.Leases[len(m.Leases)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *Member) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -13559,6 +14765,158 @@ func (m *DefragmentResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MoveLeaderRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MoveLeaderRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MoveLeaderRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TargetID", wireType)
+			}
+			m.TargetID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TargetID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MoveLeaderResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MoveLeaderResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MoveLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *AlarmRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -17073,221 +18431,235 @@ var (
 func init() { proto.RegisterFile("rpc.proto", fileDescriptorRpc) }
 
 var fileDescriptorRpc = []byte{
-	// 3450 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0x5b, 0x6f, 0x1b, 0xc7,
-	0xb9, 0x5a, 0x5e, 0xc5, 0x8f, 0x17, 0xd1, 0x23, 0xd9, 0xa6, 0x68, 0x5b, 0x96, 0xc7, 0x37, 0xd9,
-	0x4e, 0xa4, 0x44, 0xc9, 0x39, 0x0f, 0x3e, 0x41, 0x70, 0x64, 0x89, 0xb1, 0x74, 0x24, 0x4b, 0xce,
-	0x4a, 0x76, 0x72, 0x80, 0xa0, 0xc4, 0x8a, 0x1c, 0x53, 0x0b, 0x91, 0xbb, 0xcc, 0xee, 0x92, 0x96,
-	0xd2, 0x14, 0x28, 0xd2, 0x04, 0x45, 0x0b, 0xf4, 0xa5, 0x79, 0xe8, 0xed, 0xb1, 0x28, 0x8a, 0xfc,
-	0x80, 0xbe, 0xf5, 0x07, 0x14, 0x7d, 0x69, 0x81, 0xfe, 0x81, 0x22, 0xed, 0x63, 0xdf, 0xfb, 0x54,
-	0xb4, 0x98, 0xdb, 0xee, 0xec, 0x72, 0x97, 0x52, 0xca, 0x26, 0x2f, 0xd6, 0xce, 0x37, 0xdf, 0x7c,
-	0xb7, 0x99, 0xef, 0x32, 0xdf, 0xd0, 0x50, 0x70, 0xfa, 0xad, 0xe5, 0xbe, 0x63, 0x7b, 0x36, 0x2a,
-	0x11, 0xaf, 0xd5, 0x76, 0x89, 0x33, 0x24, 0x4e, 0xff, 0xb0, 0x3e, 0xd7, 0xb1, 0x3b, 0x36, 0x9b,
-	0x58, 0xa1, 0x5f, 0x1c, 0xa7, 0x3e, 0x4f, 0x71, 0x56, 0x7a, 0xc3, 0x56, 0x8b, 0xfd, 0xd3, 0x3f,
-	0x5c, 0x39, 0x1e, 0x8a, 0xa9, 0x2b, 0x6c, 0xca, 0x18, 0x78, 0x47, 0xec, 0x9f, 0xfe, 0x21, 0xfb,
-	0x23, 0x26, 0xaf, 0x76, 0x6c, 0xbb, 0xd3, 0x25, 0x2b, 0x46, 0xdf, 0x5c, 0x31, 0x2c, 0xcb, 0xf6,
-	0x0c, 0xcf, 0xb4, 0x2d, 0x97, 0xcf, 0xe2, 0xcf, 0x34, 0xa8, 0xe8, 0xc4, 0xed, 0xdb, 0x96, 0x4b,
-	0x36, 0x89, 0xd1, 0x26, 0x0e, 0xba, 0x06, 0xd0, 0xea, 0x0e, 0x5c, 0x8f, 0x38, 0x4d, 0xb3, 0x5d,
-	0xd3, 0x16, 0xb5, 0xa5, 0x8c, 0x5e, 0x10, 0x90, 0xad, 0x36, 0xba, 0x02, 0x85, 0x1e, 0xe9, 0x1d,
-	0xf2, 0xd9, 0x14, 0x9b, 0x9d, 0xe6, 0x80, 0xad, 0x36, 0xaa, 0xc3, 0xb4, 0x43, 0x86, 0xa6, 0x6b,
-	0xda, 0x56, 0x2d, 0xbd, 0xa8, 0x2d, 0xa5, 0x75, 0x7f, 0x4c, 0x17, 0x3a, 0xc6, 0x0b, 0xaf, 0xe9,
-	0x11, 0xa7, 0x57, 0xcb, 0xf0, 0x85, 0x14, 0x70, 0x40, 0x9c, 0x1e, 0xfe, 0x34, 0x0b, 0x25, 0xdd,
-	0xb0, 0x3a, 0x44, 0x27, 0x1f, 0x0e, 0x88, 0xeb, 0xa1, 0x2a, 0xa4, 0x8f, 0xc9, 0x29, 0x63, 0x5f,
-	0xd2, 0xe9, 0x27, 0x5f, 0x6f, 0x75, 0x48, 0x93, 0x58, 0x9c, 0x71, 0x89, 0xae, 0xb7, 0x3a, 0xa4,
-	0x61, 0xb5, 0xd1, 0x1c, 0x64, 0xbb, 0x66, 0xcf, 0xf4, 0x04, 0x57, 0x3e, 0x08, 0x89, 0x93, 0x89,
-	0x88, 0xb3, 0x0e, 0xe0, 0xda, 0x8e, 0xd7, 0xb4, 0x9d, 0x36, 0x71, 0x6a, 0xd9, 0x45, 0x6d, 0xa9,
-	0xb2, 0x7a, 0x6b, 0x59, 0xdd, 0x88, 0x65, 0x55, 0xa0, 0xe5, 0x7d, 0xdb, 0xf1, 0xf6, 0x28, 0xae,
-	0x5e, 0x70, 0xe5, 0x27, 0x7a, 0x07, 0x8a, 0x8c, 0x88, 0x67, 0x38, 0x1d, 0xe2, 0xd5, 0x72, 0x8c,
-	0xca, 0xed, 0x33, 0xa8, 0x1c, 0x30, 0x64, 0x9d, 0xb1, 0xe7, 0xdf, 0x08, 0x43, 0xc9, 0x25, 0x8e,
-	0x69, 0x74, 0xcd, 0x8f, 0x8c, 0xc3, 0x2e, 0xa9, 0xe5, 0x17, 0xb5, 0xa5, 0x69, 0x3d, 0x04, 0xa3,
-	0xfa, 0x1f, 0x93, 0x53, 0xb7, 0x69, 0x5b, 0xdd, 0xd3, 0xda, 0x34, 0x43, 0x98, 0xa6, 0x80, 0x3d,
-	0xab, 0x7b, 0xca, 0x36, 0xcd, 0x1e, 0x58, 0x1e, 0x9f, 0x2d, 0xb0, 0xd9, 0x02, 0x83, 0xb0, 0xe9,
-	0x25, 0xa8, 0xf6, 0x4c, 0xab, 0xd9, 0xb3, 0xdb, 0x4d, 0xdf, 0x20, 0xc0, 0x0c, 0x52, 0xe9, 0x99,
-	0xd6, 0x13, 0xbb, 0xad, 0x4b, 0xb3, 0x50, 0x4c, 0xe3, 0x24, 0x8c, 0x59, 0x14, 0x98, 0xc6, 0x89,
-	0x8a, 0xb9, 0x0c, 0xb3, 0x94, 0x66, 0xcb, 0x21, 0x86, 0x47, 0x02, 0xe4, 0x12, 0x43, 0xbe, 0xd0,
-	0x33, 0xad, 0x75, 0x36, 0x13, 0xc2, 0x37, 0x4e, 0x46, 0xf0, 0xcb, 0x02, 0xdf, 0x38, 0x09, 0xe3,
-	0xe3, 0x65, 0x28, 0xf8, 0x36, 0x47, 0xd3, 0x90, 0xd9, 0xdd, 0xdb, 0x6d, 0x54, 0xa7, 0x10, 0x40,
-	0x6e, 0x6d, 0x7f, 0xbd, 0xb1, 0xbb, 0x51, 0xd5, 0x50, 0x11, 0xf2, 0x1b, 0x0d, 0x3e, 0x48, 0xe1,
-	0x47, 0x00, 0x81, 0x75, 0x51, 0x1e, 0xd2, 0xdb, 0x8d, 0xff, 0xaf, 0x4e, 0x51, 0x9c, 0xe7, 0x0d,
-	0x7d, 0x7f, 0x6b, 0x6f, 0xb7, 0xaa, 0xd1, 0xc5, 0xeb, 0x7a, 0x63, 0xed, 0xa0, 0x51, 0x4d, 0x51,
-	0x8c, 0x27, 0x7b, 0x1b, 0xd5, 0x34, 0x2a, 0x40, 0xf6, 0xf9, 0xda, 0xce, 0xb3, 0x46, 0x35, 0x83,
-	0x3f, 0xd7, 0xa0, 0x2c, 0xf6, 0x8b, 0xfb, 0x04, 0x7a, 0x13, 0x72, 0x47, 0xcc, 0x2f, 0xd8, 0x51,
-	0x2c, 0xae, 0x5e, 0x8d, 0x6c, 0x6e, 0xc8, 0x77, 0x74, 0x81, 0x8b, 0x30, 0xa4, 0x8f, 0x87, 0x6e,
-	0x2d, 0xb5, 0x98, 0x5e, 0x2a, 0xae, 0x56, 0x97, 0xb9, 0xc3, 0x2e, 0x6f, 0x93, 0xd3, 0xe7, 0x46,
-	0x77, 0x40, 0x74, 0x3a, 0x89, 0x10, 0x64, 0x7a, 0xb6, 0x43, 0xd8, 0x89, 0x9d, 0xd6, 0xd9, 0x37,
-	0x3d, 0xc6, 0x6c, 0xd3, 0xc4, 0x69, 0xe5, 0x03, 0xfc, 0x85, 0x06, 0xf0, 0x74, 0xe0, 0x25, 0xbb,
-	0xc6, 0x1c, 0x64, 0x87, 0x94, 0xb0, 0x70, 0x0b, 0x3e, 0x60, 0x3e, 0x41, 0x0c, 0x97, 0xf8, 0x3e,
-	0x41, 0x07, 0xe8, 0x32, 0xe4, 0xfb, 0x0e, 0x19, 0x36, 0x8f, 0x87, 0x8c, 0xc9, 0xb4, 0x9e, 0xa3,
-	0xc3, 0xed, 0x21, 0xba, 0x01, 0x25, 0xb3, 0x63, 0xd9, 0x0e, 0x69, 0x72, 0x5a, 0x59, 0x36, 0x5b,
-	0xe4, 0x30, 0x26, 0xb7, 0x82, 0xc2, 0x09, 0xe7, 0x54, 0x94, 0x1d, 0x0a, 0xc2, 0x16, 0x14, 0x99,
-	0xa8, 0x13, 0x99, 0xef, 0x5e, 0x20, 0x63, 0x8a, 0x2d, 0x1b, 0x35, 0xa1, 0x90, 0x1a, 0x7f, 0x00,
-	0x68, 0x83, 0x74, 0x89, 0x47, 0x26, 0x89, 0x1e, 0x8a, 0x4d, 0xd2, 0xaa, 0x4d, 0xf0, 0x8f, 0x35,
-	0x98, 0x0d, 0x91, 0x9f, 0x48, 0xad, 0x1a, 0xe4, 0xdb, 0x8c, 0x18, 0x97, 0x20, 0xad, 0xcb, 0x21,
-	0x7a, 0x00, 0xd3, 0x42, 0x00, 0xb7, 0x96, 0x4e, 0x38, 0x34, 0x79, 0x2e, 0x93, 0x8b, 0xff, 0xa6,
-	0x41, 0x41, 0x28, 0xba, 0xd7, 0x47, 0x6b, 0x50, 0x76, 0xf8, 0xa0, 0xc9, 0xf4, 0x11, 0x12, 0xd5,
-	0x93, 0x83, 0xd0, 0xe6, 0x94, 0x5e, 0x12, 0x4b, 0x18, 0x18, 0xfd, 0x0f, 0x14, 0x25, 0x89, 0xfe,
-	0xc0, 0x13, 0x26, 0xaf, 0x85, 0x09, 0x04, 0xe7, 0x6f, 0x73, 0x4a, 0x07, 0x81, 0xfe, 0x74, 0xe0,
-	0xa1, 0x03, 0x98, 0x93, 0x8b, 0xb9, 0x36, 0x42, 0x8c, 0x34, 0xa3, 0xb2, 0x18, 0xa6, 0x32, 0xba,
-	0x55, 0x9b, 0x53, 0x3a, 0x12, 0xeb, 0x95, 0xc9, 0x47, 0x05, 0xc8, 0x0b, 0x28, 0xfe, 0xbb, 0x06,
-	0x20, 0x0d, 0xba, 0xd7, 0x47, 0x1b, 0x50, 0x71, 0xc4, 0x28, 0xa4, 0xf0, 0x95, 0x58, 0x85, 0xc5,
-	0x3e, 0x4c, 0xe9, 0x65, 0xb9, 0x88, 0xab, 0xfc, 0x36, 0x94, 0x7c, 0x2a, 0x81, 0xce, 0xf3, 0x31,
-	0x3a, 0xfb, 0x14, 0x8a, 0x72, 0x01, 0xd5, 0xfa, 0x3d, 0xb8, 0xe8, 0xaf, 0x8f, 0x51, 0xfb, 0xc6,
-	0x18, 0xb5, 0x7d, 0x82, 0xb3, 0x92, 0x82, 0xaa, 0x38, 0xd0, 0x94, 0xc5, 0xc1, 0xf8, 0x8b, 0x34,
-	0xe4, 0xd7, 0xed, 0x5e, 0xdf, 0x70, 0xe8, 0x1e, 0xe5, 0x1c, 0xe2, 0x0e, 0xba, 0x1e, 0x53, 0xb7,
-	0xb2, 0x7a, 0x33, 0xcc, 0x41, 0xa0, 0xc9, 0xbf, 0x3a, 0x43, 0xd5, 0xc5, 0x12, 0xba, 0x58, 0x64,
-	0xa8, 0xd4, 0x39, 0x16, 0x8b, 0xfc, 0x24, 0x96, 0x48, 0x5f, 0x4a, 0x07, 0xbe, 0x54, 0x87, 0xfc,
-	0x90, 0x38, 0x41, 0x56, 0xdd, 0x9c, 0xd2, 0x25, 0x00, 0xdd, 0x83, 0x99, 0x68, 0x84, 0xcf, 0x0a,
-	0x9c, 0x4a, 0x2b, 0x9c, 0x10, 0x6e, 0x42, 0x29, 0x94, 0x66, 0x72, 0x02, 0xaf, 0xd8, 0x53, 0xb2,
-	0xcc, 0x25, 0x19, 0xda, 0x68, 0x4a, 0x2c, 0x6d, 0x4e, 0x89, 0xe0, 0x86, 0xff, 0x17, 0xca, 0x21,
-	0x5d, 0x69, 0x14, 0x6f, 0xbc, 0xfb, 0x6c, 0x6d, 0x87, 0x87, 0xfc, 0xc7, 0x2c, 0xca, 0xeb, 0x55,
-	0x8d, 0x66, 0x8e, 0x9d, 0xc6, 0xfe, 0x7e, 0x35, 0x85, 0xca, 0x50, 0xd8, 0xdd, 0x3b, 0x68, 0x72,
-	0xac, 0x34, 0x7e, 0xcb, 0xa7, 0x20, 0x52, 0x86, 0x92, 0x29, 0xa6, 0x94, 0x4c, 0xa1, 0xc9, 0x4c,
-	0x91, 0x0a, 0x32, 0x45, 0xfa, 0x51, 0x05, 0x4a, 0xdc, 0x3e, 0xcd, 0x81, 0x45, 0xb3, 0xd5, 0x2f,
-	0x35, 0x80, 0x83, 0x13, 0x4b, 0x06, 0xa0, 0x15, 0xc8, 0xb7, 0x38, 0xf1, 0x9a, 0xc6, 0xfc, 0xf9,
-	0x62, 0xac, 0xc9, 0x75, 0x89, 0x85, 0x5e, 0x87, 0xbc, 0x3b, 0x68, 0xb5, 0x88, 0x2b, 0xb3, 0xc6,
-	0xe5, 0x68, 0x48, 0x11, 0x0e, 0xaf, 0x4b, 0x3c, 0xba, 0xe4, 0x85, 0x61, 0x76, 0x07, 0x2c, 0x87,
-	0x8c, 0x5f, 0x22, 0xf0, 0xf0, 0xcf, 0x34, 0x28, 0x32, 0x29, 0x27, 0x8a, 0x63, 0x57, 0xa1, 0xc0,
-	0x64, 0x20, 0x6d, 0x11, 0xc9, 0xa6, 0xf5, 0x00, 0x80, 0xfe, 0x1b, 0x0a, 0xf2, 0x04, 0xcb, 0x60,
-	0x56, 0x8b, 0x27, 0xbb, 0xd7, 0xd7, 0x03, 0x54, 0xbc, 0x0d, 0x17, 0x98, 0x55, 0x5a, 0xb4, 0x3e,
-	0x95, 0x76, 0x54, 0x2b, 0x38, 0x2d, 0x52, 0xc1, 0xd5, 0x61, 0xba, 0x7f, 0x74, 0xea, 0x9a, 0x2d,
-	0xa3, 0x2b, 0xa4, 0xf0, 0xc7, 0xf8, 0xff, 0x00, 0xa9, 0xc4, 0x26, 0x51, 0x17, 0x97, 0xa1, 0xb8,
-	0x69, 0xb8, 0x47, 0x42, 0x24, 0xfc, 0x3e, 0x94, 0xf8, 0x70, 0x22, 0x1b, 0x22, 0xc8, 0x1c, 0x19,
-	0xee, 0x11, 0x13, 0xbc, 0xac, 0xb3, 0x6f, 0x7c, 0x01, 0x66, 0xf6, 0x2d, 0xa3, 0xef, 0x1e, 0xd9,
-	0x32, 0xd6, 0xd2, 0xfa, 0xbc, 0x1a, 0xc0, 0x26, 0xe2, 0x78, 0x17, 0x66, 0x1c, 0xd2, 0x33, 0x4c,
-	0xcb, 0xb4, 0x3a, 0xcd, 0xc3, 0x53, 0x8f, 0xb8, 0xa2, 0x7c, 0xaf, 0xf8, 0xe0, 0x47, 0x14, 0x4a,
-	0x45, 0x3b, 0xec, 0xda, 0x87, 0xc2, 0xe3, 0xd9, 0x37, 0xfe, 0x8d, 0x06, 0xa5, 0xf7, 0x0c, 0xaf,
-	0x25, 0xad, 0x80, 0xb6, 0xa0, 0xe2, 0xfb, 0x39, 0x83, 0x08, 0x59, 0x22, 0x01, 0x9f, 0xad, 0x91,
-	0x85, 0x9d, 0x0c, 0xf8, 0xe5, 0x96, 0x0a, 0x60, 0xa4, 0x0c, 0xab, 0x45, 0xba, 0x3e, 0xa9, 0x54,
-	0x32, 0x29, 0x86, 0xa8, 0x92, 0x52, 0x01, 0x8f, 0x66, 0x82, 0x64, 0xc8, 0xdd, 0xf2, 0xe7, 0x29,
-	0x40, 0xa3, 0x32, 0x7c, 0xd5, 0xfa, 0xe0, 0x36, 0x54, 0x5c, 0xcf, 0x70, 0xbc, 0x66, 0xe4, 0x72,
-	0x53, 0x66, 0x50, 0x3f, 0x56, 0xdd, 0x85, 0x99, 0xbe, 0x63, 0x77, 0x1c, 0xe2, 0xba, 0x4d, 0xcb,
-	0xf6, 0xcc, 0x17, 0xa7, 0xa2, 0xc4, 0xaa, 0x48, 0xf0, 0x2e, 0x83, 0xa2, 0x06, 0xe4, 0x5f, 0x98,
-	0x5d, 0x8f, 0x38, 0x6e, 0x2d, 0xbb, 0x98, 0x5e, 0xaa, 0xac, 0x3e, 0x38, 0xcb, 0x6a, 0xcb, 0xef,
-	0x30, 0xfc, 0x83, 0xd3, 0x3e, 0xd1, 0xe5, 0x5a, 0xb5, 0x6c, 0xc9, 0x85, 0xca, 0x96, 0xdb, 0x00,
-	0x01, 0x3e, 0x8d, 0x5a, 0xbb, 0x7b, 0x4f, 0x9f, 0x1d, 0x54, 0xa7, 0x50, 0x09, 0xa6, 0x77, 0xf7,
-	0x36, 0x1a, 0x3b, 0x0d, 0x1a, 0xd7, 0xf0, 0x8a, 0xb4, 0x8d, 0x6a, 0x43, 0x34, 0x0f, 0xd3, 0x2f,
-	0x29, 0x54, 0xde, 0xfe, 0xd2, 0x7a, 0x9e, 0x8d, 0xb7, 0xda, 0xf8, 0x47, 0x29, 0x28, 0x8b, 0x53,
-	0x30, 0xd1, 0x51, 0x54, 0x59, 0xa4, 0x42, 0x2c, 0x68, 0x8d, 0xc4, 0x4f, 0x47, 0x5b, 0x94, 0x62,
-	0x72, 0x48, 0xdd, 0x9d, 0x6f, 0x36, 0x69, 0x0b, 0xb3, 0xfa, 0x63, 0x74, 0x0f, 0xaa, 0x2d, 0xee,
-	0xee, 0x91, 0xb4, 0xa3, 0xcf, 0x08, 0xb8, 0x92, 0x75, 0xca, 0xfe, 0x69, 0x33, 0x5c, 0x91, 0x76,
-	0x0a, 0x7a, 0x49, 0x1e, 0x24, 0x0a, 0x43, 0xb7, 0x21, 0x47, 0x86, 0xc4, 0xf2, 0xdc, 0x5a, 0x91,
-	0x05, 0xb0, 0xb2, 0xac, 0xc6, 0x1a, 0x14, 0xaa, 0x8b, 0x49, 0xfc, 0x5f, 0x70, 0x81, 0x55, 0xbd,
-	0x8f, 0x1d, 0xc3, 0x52, 0xcb, 0xf3, 0x83, 0x83, 0x1d, 0x61, 0x3a, 0xfa, 0x89, 0x2a, 0x90, 0xda,
-	0xda, 0x10, 0x8a, 0xa6, 0xb6, 0x36, 0xf0, 0x27, 0x1a, 0x20, 0x75, 0xdd, 0x44, 0xb6, 0x8c, 0x10,
-	0x97, 0xec, 0xd3, 0x01, 0xfb, 0x39, 0xc8, 0x12, 0xc7, 0xb1, 0x1d, 0x66, 0xb5, 0x82, 0xce, 0x07,
-	0xf8, 0x96, 0x90, 0x41, 0x27, 0x43, 0xfb, 0xd8, 0x77, 0x0c, 0x4e, 0x4d, 0xf3, 0x45, 0xdd, 0x86,
-	0xd9, 0x10, 0xd6, 0x44, 0x81, 0xf4, 0x2e, 0x5c, 0x64, 0xc4, 0xb6, 0x09, 0xe9, 0xaf, 0x75, 0xcd,
-	0x61, 0x22, 0xd7, 0x3e, 0x5c, 0x8a, 0x22, 0x7e, 0xbd, 0x36, 0xc2, 0x6f, 0x09, 0x8e, 0x07, 0x66,
-	0x8f, 0x1c, 0xd8, 0x3b, 0xc9, 0xb2, 0xd1, 0xe8, 0x48, 0x6f, 0xdd, 0x22, 0xe3, 0xb0, 0x6f, 0xfc,
-	0x2b, 0x0d, 0x2e, 0x8f, 0x2c, 0xff, 0x9a, 0x77, 0x75, 0x01, 0xa0, 0x43, 0x8f, 0x0f, 0x69, 0xd3,
-	0x09, 0x7e, 0x5f, 0x54, 0x20, 0xbe, 0x9c, 0x34, 0xc0, 0x94, 0x84, 0x9c, 0x47, 0x90, 0x7b, 0xc2,
-	0x5a, 0x35, 0x8a, 0x56, 0x19, 0xa9, 0x95, 0x65, 0xf4, 0xf8, 0x05, 0xb2, 0xa0, 0xb3, 0x6f, 0x96,
-	0x5f, 0x09, 0x71, 0x9e, 0xe9, 0x3b, 0x3c, 0x8f, 0x17, 0x74, 0x7f, 0x4c, 0xb9, 0xb7, 0xba, 0x26,
-	0xb1, 0x3c, 0x36, 0x9b, 0x61, 0xb3, 0x0a, 0x04, 0x2f, 0x43, 0x95, 0x73, 0x5a, 0x6b, 0xb7, 0x95,
-	0x5c, 0xee, 0xd3, 0xd3, 0xc2, 0xf4, 0xf0, 0xaf, 0x35, 0xb8, 0xa0, 0x2c, 0x98, 0xc8, 0x76, 0xaf,
-	0x40, 0x8e, 0x37, 0xa4, 0x44, 0x1e, 0x99, 0x0b, 0xaf, 0xe2, 0x6c, 0x74, 0x81, 0x83, 0x96, 0x21,
-	0xcf, 0xbf, 0x64, 0xb1, 0x12, 0x8f, 0x2e, 0x91, 0xf0, 0x6d, 0x98, 0x15, 0x20, 0xd2, 0xb3, 0xe3,
-	0x8e, 0x09, 0x33, 0x28, 0xfe, 0x18, 0xe6, 0xc2, 0x68, 0x13, 0xa9, 0xa4, 0x08, 0x99, 0x3a, 0x8f,
-	0x90, 0x6b, 0x52, 0xc8, 0x67, 0xfd, 0xb6, 0x92, 0xf6, 0xa2, 0xbb, 0xae, 0xee, 0x48, 0x2a, 0xb2,
-	0x23, 0xbe, 0x02, 0x92, 0xc4, 0x37, 0xaa, 0xc0, 0xac, 0x3c, 0x0e, 0x3b, 0xa6, 0xeb, 0x17, 0x43,
-	0x1f, 0x01, 0x52, 0x81, 0xdf, 0xb4, 0x40, 0x1b, 0xe4, 0x85, 0x63, 0x74, 0x7a, 0xc4, 0x0f, 0xf5,
-	0xb4, 0xca, 0x54, 0x81, 0x13, 0x05, 0xc7, 0x3f, 0x68, 0x50, 0x5a, 0xeb, 0x1a, 0x4e, 0x4f, 0x6e,
-	0xd6, 0xdb, 0x90, 0xe3, 0xe5, 0xab, 0xb8, 0xf1, 0xdd, 0x09, 0x93, 0x51, 0x71, 0xf9, 0x60, 0x8d,
-	0x17, 0xbb, 0x62, 0x15, 0xdd, 0x5c, 0xd1, 0x97, 0xdd, 0x88, 0xf4, 0x69, 0x37, 0xd0, 0xab, 0x90,
-	0x35, 0xe8, 0x12, 0x16, 0x50, 0x2a, 0xd1, 0x8b, 0x03, 0xa3, 0xc6, 0x4a, 0x0d, 0x8e, 0x85, 0xdf,
-	0x84, 0xa2, 0xc2, 0x81, 0xde, 0x87, 0x1e, 0x37, 0x44, 0x39, 0xb1, 0xb6, 0x7e, 0xb0, 0xf5, 0x9c,
-	0x5f, 0x93, 0x2a, 0x00, 0x1b, 0x0d, 0x7f, 0x9c, 0xc2, 0xef, 0x8b, 0x55, 0x22, 0xe4, 0xa8, 0xf2,
-	0x68, 0x49, 0xf2, 0xa4, 0xce, 0x25, 0xcf, 0x09, 0x94, 0x85, 0xfa, 0x13, 0x9d, 0x81, 0xd7, 0x21,
-	0xc7, 0xe8, 0xc9, 0x23, 0x30, 0x1f, 0xc3, 0x56, 0x46, 0x0b, 0x8e, 0x88, 0x67, 0xa0, 0xbc, 0xef,
-	0x19, 0xde, 0xc0, 0x95, 0x47, 0xe0, 0xf7, 0x1a, 0x54, 0x24, 0x64, 0xd2, 0xe6, 0x90, 0xbc, 0x54,
-	0xf3, 0x20, 0xec, 0x5f, 0xa9, 0x2f, 0x41, 0xae, 0x7d, 0xb8, 0x6f, 0x7e, 0x24, 0x1b, 0x79, 0x62,
-	0x44, 0xe1, 0x5d, 0xce, 0x87, 0x77, 0xd3, 0xc5, 0x88, 0x5e, 0xcf, 0x1c, 0xe3, 0x85, 0xb7, 0x65,
-	0xb5, 0xc9, 0x09, 0xab, 0x82, 0x32, 0x7a, 0x00, 0x60, 0x37, 0x2a, 0xd1, 0x75, 0x67, 0xa5, 0x8f,
-	0xda, 0x85, 0x9f, 0x85, 0x0b, 0x6b, 0x03, 0xef, 0xa8, 0x61, 0x19, 0x87, 0x5d, 0x19, 0x34, 0xf0,
-	0x1c, 0x20, 0x0a, 0xdc, 0x30, 0x5d, 0x15, 0xda, 0x80, 0x59, 0x0a, 0x25, 0x96, 0x67, 0xb6, 0x94,
-	0x08, 0x23, 0xf3, 0x88, 0x16, 0xc9, 0x23, 0x86, 0xeb, 0xbe, 0xb4, 0x9d, 0xb6, 0x50, 0xcd, 0x1f,
-	0xe3, 0x0d, 0x4e, 0xfc, 0x99, 0x1b, 0xca, 0x14, 0x5f, 0x95, 0xca, 0x52, 0x40, 0xe5, 0x31, 0xf1,
-	0xc6, 0x50, 0xc1, 0x0f, 0xe0, 0xa2, 0xc4, 0x14, 0x5d, 0x97, 0x31, 0xc8, 0x7b, 0x70, 0x4d, 0x22,
-	0xaf, 0x1f, 0xd1, 0xbb, 0xc0, 0x53, 0xc1, 0xf0, 0xdf, 0x95, 0xf3, 0x11, 0xd4, 0x7c, 0x39, 0x59,
-	0xe9, 0x67, 0x77, 0x55, 0x01, 0x06, 0xae, 0x38, 0x33, 0x05, 0x9d, 0x7d, 0x53, 0x98, 0x63, 0x77,
-	0xfd, 0xac, 0x4c, 0xbf, 0xf1, 0x3a, 0xcc, 0x4b, 0x1a, 0xa2, 0x28, 0x0b, 0x13, 0x19, 0x11, 0x28,
-	0x8e, 0x88, 0x30, 0x18, 0x5d, 0x3a, 0xde, 0xec, 0x2a, 0x66, 0xd8, 0xb4, 0x8c, 0xa6, 0xa6, 0xd0,
-	0xbc, 0xc8, 0x4f, 0x04, 0x15, 0x4c, 0x0d, 0xda, 0x02, 0x4c, 0x09, 0xa8, 0x60, 0xb1, 0x11, 0x14,
-	0x3c, 0xb2, 0x11, 0x23, 0xa4, 0x3f, 0x80, 0x05, 0x5f, 0x08, 0x6a, 0xb7, 0xa7, 0xc4, 0xe9, 0x99,
-	0xae, 0xab, 0xf4, 0x09, 0xe2, 0x14, 0xbf, 0x03, 0x99, 0x3e, 0x11, 0x31, 0xa5, 0xb8, 0x8a, 0x96,
-	0xf9, 0xdb, 0xd8, 0xb2, 0xb2, 0x98, 0xcd, 0xe3, 0x36, 0x5c, 0x97, 0xd4, 0xb9, 0x45, 0x63, 0xc9,
-	0x47, 0x85, 0x92, 0x77, 0x48, 0x6e, 0xd6, 0xd1, 0x3b, 0x64, 0x9a, 0xef, 0xbd, 0xbc, 0x43, 0xd2,
-	0x5c, 0xa1, 0xfa, 0xd6, 0x44, 0xb9, 0x62, 0x9b, 0xdb, 0xd4, 0x77, 0xc9, 0x89, 0x88, 0x1d, 0xc2,
-	0x5c, 0xd8, 0x93, 0x27, 0x0a, 0x63, 0x73, 0x90, 0xf5, 0xec, 0x63, 0x22, 0x83, 0x18, 0x1f, 0x48,
-	0x81, 0x7d, 0x37, 0x9f, 0x48, 0x60, 0x23, 0x20, 0xc6, 0x8e, 0xe4, 0xa4, 0xf2, 0xd2, 0xdd, 0x94,
-	0xf5, 0x0f, 0x1f, 0xe0, 0x5d, 0xb8, 0x14, 0x0d, 0x13, 0x13, 0x89, 0xfc, 0x9c, 0x1f, 0xe0, 0xb8,
-	0x48, 0x32, 0x11, 0xdd, 0x77, 0x83, 0x60, 0xa0, 0x04, 0x94, 0x89, 0x48, 0xea, 0x50, 0x8f, 0x8b,
-	0x2f, 0xff, 0x89, 0xf3, 0xea, 0x87, 0x9b, 0x89, 0x88, 0xb9, 0x01, 0xb1, 0xc9, 0xb7, 0x3f, 0x88,
-	0x11, 0xe9, 0xb1, 0x31, 0x42, 0x38, 0x49, 0x10, 0xc5, 0xbe, 0x86, 0x43, 0x27, 0x78, 0x04, 0x01,
-	0x74, 0x52, 0x1e, 0x34, 0x87, 0xf8, 0x3c, 0xd8, 0x40, 0x1e, 0x6c, 0x35, 0xec, 0x4e, 0xb4, 0x19,
-	0xef, 0x05, 0xb1, 0x73, 0x24, 0x32, 0x4f, 0x44, 0xf8, 0x7d, 0x58, 0x4c, 0x0e, 0xca, 0x93, 0x50,
-	0xbe, 0x8f, 0xa1, 0xe0, 0x17, 0x94, 0xca, 0xbb, 0x72, 0x11, 0xf2, 0xbb, 0x7b, 0xfb, 0x4f, 0xd7,
-	0xd6, 0x1b, 0x55, 0x6d, 0xf5, 0x1f, 0x69, 0x48, 0x6d, 0x3f, 0x47, 0xdf, 0x82, 0x2c, 0x7f, 0x2e,
-	0x1a, 0xf3, 0x9a, 0x56, 0x1f, 0xf7, 0xf0, 0x84, 0xaf, 0x7e, 0xf2, 0xa7, 0xbf, 0x7e, 0x9e, 0xba,
-	0x84, 0x2f, 0xac, 0x0c, 0xdf, 0x30, 0xba, 0xfd, 0x23, 0x63, 0xe5, 0x78, 0xb8, 0xc2, 0x72, 0xc2,
-	0x43, 0xed, 0x3e, 0x7a, 0x0e, 0xe9, 0xa7, 0x03, 0x0f, 0x25, 0x3e, 0xb5, 0xd5, 0x93, 0x1f, 0xa4,
-	0x70, 0x9d, 0x51, 0x9e, 0xc3, 0x33, 0x2a, 0xe5, 0xfe, 0xc0, 0xa3, 0x74, 0x87, 0x50, 0x54, 0xde,
-	0x94, 0xd0, 0x99, 0x8f, 0x70, 0xf5, 0xb3, 0xdf, 0xab, 0x30, 0x66, 0xfc, 0xae, 0xe2, 0xcb, 0x2a,
-	0x3f, 0xfe, 0xf4, 0xa5, 0xea, 0x73, 0x70, 0x62, 0x45, 0xf5, 0x09, 0x9e, 0x45, 0xa2, 0xfa, 0x28,
-	0x4f, 0x11, 0xf1, 0xfa, 0x78, 0x27, 0x16, 0xa5, 0x6b, 0x8b, 0x77, 0xb0, 0x96, 0x87, 0xae, 0xc7,
-	0xbc, 0xa3, 0xa8, 0x2f, 0x06, 0xf5, 0xc5, 0x64, 0x04, 0xc1, 0xe9, 0x06, 0xe3, 0x74, 0x05, 0x5f,
-	0x52, 0x39, 0xb5, 0x7c, 0xbc, 0x87, 0xda, 0xfd, 0xd5, 0x23, 0xc8, 0xb2, 0x3e, 0x27, 0x6a, 0xca,
-	0x8f, 0x7a, 0x4c, 0x87, 0x36, 0xe1, 0x04, 0x84, 0x3a, 0xa4, 0x78, 0x9e, 0x71, 0x9b, 0xc5, 0x15,
-	0x9f, 0x1b, 0x6b, 0x75, 0x3e, 0xd4, 0xee, 0x2f, 0x69, 0xaf, 0x69, 0xab, 0xdf, 0xcb, 0x40, 0x96,
-	0xb5, 0x8e, 0x50, 0x1f, 0x20, 0x68, 0x0a, 0x46, 0xf5, 0x1c, 0x69, 0x33, 0x46, 0xf5, 0x1c, 0xed,
-	0x27, 0xe2, 0xeb, 0x8c, 0xf3, 0x3c, 0x9e, 0xf3, 0x39, 0xb3, 0x57, 0xfb, 0x15, 0xd6, 0x24, 0xa2,
-	0x66, 0x7d, 0x09, 0x45, 0xa5, 0xb9, 0x87, 0xe2, 0x28, 0x86, 0xba, 0x83, 0xd1, 0x63, 0x12, 0xd3,
-	0x19, 0xc4, 0x37, 0x19, 0xd3, 0x6b, 0xb8, 0xa6, 0x1a, 0x97, 0xf3, 0x75, 0x18, 0x26, 0x65, 0xfc,
-	0xa9, 0x06, 0x95, 0x70, 0x83, 0x0f, 0xdd, 0x8c, 0x21, 0x1d, 0xed, 0x13, 0xd6, 0x6f, 0x8d, 0x47,
-	0x4a, 0x14, 0x81, 0xf3, 0x3f, 0x26, 0xa4, 0x6f, 0x50, 0x4c, 0x61, 0x7b, 0xf4, 0x7d, 0x0d, 0x66,
-	0x22, 0x6d, 0x3b, 0x14, 0xc7, 0x62, 0xa4, 0x29, 0x58, 0xbf, 0x7d, 0x06, 0x96, 0x90, 0xe4, 0x2e,
-	0x93, 0xe4, 0x06, 0xbe, 0x3a, 0x6a, 0x0c, 0xcf, 0xec, 0x11, 0xcf, 0x16, 0xd2, 0xac, 0xfe, 0x33,
-	0x0d, 0xf9, 0x75, 0xfe, 0x13, 0x2b, 0xe4, 0x41, 0xc1, 0xef, 0x84, 0xa1, 0x85, 0xb8, 0xae, 0x44,
-	0x50, 0xb2, 0xd7, 0xaf, 0x27, 0xce, 0x0b, 0x11, 0xee, 0x30, 0x11, 0x16, 0xf1, 0x15, 0x5f, 0x04,
-	0xf1, 0x53, 0xae, 0x15, 0x7e, 0xf9, 0x5e, 0x31, 0xda, 0x6d, 0xba, 0x25, 0xdf, 0xd5, 0xa0, 0xa4,
-	0x36, 0xac, 0xd0, 0x8d, 0xd8, 0x7e, 0x88, 0xda, 0xf3, 0xaa, 0xe3, 0x71, 0x28, 0x82, 0xff, 0x3d,
-	0xc6, 0xff, 0x26, 0x5e, 0x48, 0xe2, 0xef, 0x30, 0xfc, 0xb0, 0x08, 0xbc, 0xe5, 0x14, 0x2f, 0x42,
-	0xa8, 0xa3, 0x15, 0x2f, 0x42, 0xb8, 0x63, 0x75, 0xb6, 0x08, 0x03, 0x86, 0x4f, 0x45, 0x38, 0x01,
-	0x08, 0x3a, 0x4c, 0x28, 0xd6, 0xb8, 0xca, 0x25, 0x26, 0xea, 0x83, 0xa3, 0xcd, 0xa9, 0x98, 0x13,
-	0x10, 0xe1, 0xdd, 0x35, 0x5d, 0xea, 0x8b, 0xab, 0xbf, 0xcd, 0x40, 0xf1, 0x89, 0x61, 0x5a, 0x1e,
-	0xb1, 0x0c, 0xab, 0x45, 0x50, 0x07, 0xb2, 0x2c, 0x4b, 0x45, 0x03, 0x8f, 0xda, 0xf6, 0x89, 0x06,
-	0x9e, 0x50, 0x4f, 0x04, 0xdf, 0x66, 0xac, 0xaf, 0xe3, 0xba, 0xcf, 0xba, 0x17, 0xd0, 0x5f, 0x61,
-	0xfd, 0x0c, 0xaa, 0xf2, 0x31, 0xe4, 0x78, 0xff, 0x02, 0x45, 0xa8, 0x85, 0xfa, 0x1c, 0xf5, 0xab,
-	0xf1, 0x93, 0x89, 0xa7, 0x4c, 0xe5, 0xe5, 0x32, 0x64, 0xca, 0xec, 0xdb, 0x00, 0x41, 0xc3, 0x2c,
-	0x6a, 0xdf, 0x91, 0xfe, 0x5a, 0x7d, 0x31, 0x19, 0x41, 0x30, 0xbe, 0xcf, 0x18, 0xdf, 0xc2, 0xd7,
-	0x63, 0x19, 0xb7, 0xfd, 0x05, 0x94, 0x79, 0x0b, 0x32, 0x9b, 0x86, 0x7b, 0x84, 0x22, 0x49, 0x48,
-	0x79, 0xdb, 0xad, 0xd7, 0xe3, 0xa6, 0x04, 0xab, 0x5b, 0x8c, 0xd5, 0x02, 0x9e, 0x8f, 0x65, 0x75,
-	0x64, 0xb8, 0x34, 0xa6, 0xa3, 0x01, 0x4c, 0xcb, 0xf7, 0x5a, 0x74, 0x2d, 0x62, 0xb3, 0xf0, 0xdb,
-	0x6e, 0x7d, 0x21, 0x69, 0x5a, 0x30, 0x5c, 0x62, 0x0c, 0x31, 0xbe, 0x16, 0x6f, 0x54, 0x81, 0xfe,
-	0x50, 0xbb, 0xff, 0x9a, 0xb6, 0xfa, 0xc3, 0x2a, 0x64, 0x68, 0xbd, 0x44, 0xb3, 0x48, 0x70, 0xcd,
-	0x8c, 0x5a, 0x78, 0xa4, 0xb9, 0x13, 0xb5, 0xf0, 0xe8, 0x0d, 0x35, 0x26, 0x8b, 0xb0, 0x1f, 0x9a,
-	0x12, 0x86, 0x45, 0x35, 0xf6, 0xa0, 0xa8, 0x5c, 0x46, 0x51, 0x0c, 0xc5, 0x70, 0xeb, 0x28, 0x9a,
-	0x45, 0x62, 0x6e, 0xb2, 0x78, 0x91, 0x31, 0xad, 0xe3, 0x8b, 0x61, 0xa6, 0x6d, 0x8e, 0x46, 0xb9,
-	0x7e, 0x0c, 0x25, 0xf5, 0xd6, 0x8a, 0x62, 0x88, 0x46, 0x7a, 0x53, 0xd1, 0x58, 0x11, 0x77, 0xe9,
-	0x8d, 0x71, 0x1a, 0xff, 0x67, 0xb5, 0x12, 0x97, 0x72, 0xff, 0x10, 0xf2, 0xe2, 0x2e, 0x1b, 0xa7,
-	0x6f, 0xb8, 0x9b, 0x15, 0xa7, 0x6f, 0xe4, 0x22, 0x1c, 0x53, 0x92, 0x30, 0xb6, 0xb4, 0x66, 0x97,
-	0x01, 0x5a, 0xb0, 0x7c, 0x4c, 0xbc, 0x24, 0x96, 0x41, 0x7f, 0x26, 0x89, 0xa5, 0x72, 0x5f, 0x1a,
-	0xcb, 0xb2, 0x43, 0x3c, 0x71, 0x96, 0xe5, 0x65, 0x04, 0x25, 0x50, 0x54, 0xa3, 0x21, 0x1e, 0x87,
-	0x92, 0x58, 0x45, 0x06, 0x5c, 0x45, 0x28, 0x44, 0xdf, 0x01, 0x08, 0x2e, 0xde, 0xd1, 0xc2, 0x20,
-	0xb6, 0x7b, 0x17, 0x2d, 0x0c, 0xe2, 0xef, 0xee, 0x31, 0x1e, 0x1c, 0x30, 0xe7, 0x95, 0x2c, 0x65,
-	0xff, 0x13, 0x0d, 0xd0, 0xe8, 0x45, 0x1d, 0x3d, 0x88, 0x67, 0x11, 0xdb, 0x18, 0xac, 0xbf, 0x72,
-	0x3e, 0xe4, 0xc4, 0xe8, 0x19, 0xc8, 0xd5, 0x62, 0x4b, 0xfa, 0x2f, 0xa9, 0x64, 0x9f, 0x69, 0x50,
-	0x0e, 0x5d, 0xf5, 0xd1, 0x9d, 0x84, 0x7d, 0x8e, 0x34, 0x17, 0xeb, 0x77, 0xcf, 0xc4, 0x4b, 0xac,
-	0x9d, 0x94, 0x53, 0x21, 0xeb, 0xc6, 0x1f, 0x68, 0x50, 0x09, 0xf7, 0x07, 0x50, 0x02, 0x83, 0x91,
-	0x0e, 0x65, 0x7d, 0xe9, 0x6c, 0xc4, 0x73, 0xec, 0x56, 0x50, 0x4a, 0x7e, 0x08, 0x79, 0xd1, 0x56,
-	0x88, 0x73, 0x8b, 0x70, 0x83, 0x33, 0xce, 0x2d, 0x22, 0x3d, 0x89, 0x24, 0xb7, 0xa0, 0x37, 0x74,
-	0xc5, 0x13, 0x45, 0xf3, 0x21, 0x89, 0xe5, 0x78, 0x4f, 0x8c, 0x74, 0x2e, 0xc6, 0xb2, 0x0c, 0x3c,
-	0x51, 0xb6, 0x1e, 0x50, 0x02, 0xc5, 0x33, 0x3c, 0x31, 0xda, 0xb9, 0x48, 0xf2, 0x44, 0xc6, 0x55,
-	0xf1, 0xc4, 0xa0, 0x53, 0x10, 0xe7, 0x89, 0x23, 0xed, 0xdb, 0x38, 0x4f, 0x1c, 0x6d, 0x36, 0x24,
-	0xed, 0x2d, 0x63, 0x1e, 0xf2, 0xc4, 0xd9, 0x98, 0xce, 0x02, 0x7a, 0x25, 0xc1, 0xa6, 0xb1, 0xad,
-	0xe1, 0xfa, 0xab, 0xe7, 0xc4, 0x1e, 0xef, 0x01, 0x7c, 0x37, 0xa4, 0x07, 0xfc, 0x42, 0x83, 0xb9,
-	0xb8, 0xd6, 0x04, 0x4a, 0x60, 0x96, 0xd0, 0x57, 0xae, 0x2f, 0x9f, 0x17, 0xfd, 0x1c, 0x76, 0xf3,
-	0x7d, 0xe2, 0x51, 0xf5, 0x77, 0x5f, 0x2e, 0x68, 0x7f, 0xfc, 0x72, 0x41, 0xfb, 0xf3, 0x97, 0x0b,
-	0xda, 0x4f, 0xff, 0xb2, 0x30, 0x75, 0x98, 0x63, 0xff, 0xdb, 0xe3, 0x8d, 0x7f, 0x05, 0x00, 0x00,
-	0xff, 0xff, 0x63, 0x1c, 0x78, 0x24, 0x74, 0x32, 0x00, 0x00,
+	// 3669 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5b, 0x5b, 0x6f, 0x23, 0xc7,
+	0x72, 0xd6, 0x90, 0x22, 0x29, 0x16, 0x2f, 0xe2, 0xb6, 0xb4, 0xbb, 0x14, 0x77, 0x57, 0xab, 0xed,
+	0xbd, 0x69, 0x2f, 0x16, 0x6d, 0xd9, 0xc9, 0xc3, 0x26, 0x30, 0xac, 0x95, 0xe8, 0x95, 0x2c, 0xad,
+	0x24, 0x8f, 0xa8, 0xb5, 0x03, 0x38, 0x11, 0x46, 0x64, 0x4b, 0x62, 0x44, 0xce, 0x30, 0x33, 0x43,
+	0xae, 0xb4, 0x31, 0x12, 0xc0, 0x71, 0x82, 0xbc, 0xe4, 0x25, 0x06, 0x82, 0xc4, 0xaf, 0x41, 0x60,
+	0xf8, 0x07, 0x04, 0xf9, 0x0b, 0x41, 0x5e, 0x12, 0x20, 0x7f, 0xe0, 0xc0, 0xe7, 0xbc, 0x9c, 0x5f,
+	0x70, 0x2e, 0x4f, 0x07, 0x7d, 0x9b, 0xe9, 0xb9, 0x51, 0xb2, 0x69, 0xfb, 0x45, 0x3b, 0x5d, 0x5d,
+	0x5d, 0x55, 0x5d, 0xdd, 0x55, 0xd5, 0xfd, 0x35, 0x17, 0xf2, 0x76, 0xbf, 0xb5, 0xd4, 0xb7, 0x2d,
+	0xd7, 0x42, 0x45, 0xe2, 0xb6, 0xda, 0x0e, 0xb1, 0x87, 0xc4, 0xee, 0x1f, 0xd6, 0x66, 0x8f, 0xad,
+	0x63, 0x8b, 0x75, 0xd4, 0xe9, 0x17, 0xe7, 0xa9, 0xcd, 0x51, 0x9e, 0x7a, 0x6f, 0xd8, 0x6a, 0xb1,
+	0x3f, 0xfd, 0xc3, 0xfa, 0xe9, 0x50, 0x74, 0xdd, 0x60, 0x5d, 0xc6, 0xc0, 0x3d, 0x61, 0x7f, 0xfa,
+	0x87, 0xec, 0x1f, 0xd1, 0x79, 0xf3, 0xd8, 0xb2, 0x8e, 0xbb, 0xa4, 0x6e, 0xf4, 0x3b, 0x75, 0xc3,
+	0x34, 0x2d, 0xd7, 0x70, 0x3b, 0x96, 0xe9, 0xf0, 0x5e, 0xfc, 0xf7, 0x1a, 0x94, 0x75, 0xe2, 0xf4,
+	0x2d, 0xd3, 0x21, 0xeb, 0xc4, 0x68, 0x13, 0x1b, 0xdd, 0x02, 0x68, 0x75, 0x07, 0x8e, 0x4b, 0xec,
+	0x83, 0x4e, 0xbb, 0xaa, 0x2d, 0x68, 0x8b, 0x93, 0x7a, 0x5e, 0x50, 0x36, 0xda, 0xe8, 0x06, 0xe4,
+	0x7b, 0xa4, 0x77, 0xc8, 0x7b, 0x53, 0xac, 0x77, 0x8a, 0x13, 0x36, 0xda, 0xa8, 0x06, 0x53, 0x36,
+	0x19, 0x76, 0x9c, 0x8e, 0x65, 0x56, 0xd3, 0x0b, 0xda, 0x62, 0x5a, 0xf7, 0xda, 0x74, 0xa0, 0x6d,
+	0x1c, 0xb9, 0x07, 0x2e, 0xb1, 0x7b, 0xd5, 0x49, 0x3e, 0x90, 0x12, 0x9a, 0xc4, 0xee, 0xe1, 0x2f,
+	0x33, 0x50, 0xd4, 0x0d, 0xf3, 0x98, 0xe8, 0xe4, 0xaf, 0x06, 0xc4, 0x71, 0x51, 0x05, 0xd2, 0xa7,
+	0xe4, 0x9c, 0xa9, 0x2f, 0xea, 0xf4, 0x93, 0x8f, 0x37, 0x8f, 0xc9, 0x01, 0x31, 0xb9, 0xe2, 0x22,
+	0x1d, 0x6f, 0x1e, 0x93, 0x86, 0xd9, 0x46, 0xb3, 0x90, 0xe9, 0x76, 0x7a, 0x1d, 0x57, 0x68, 0xe5,
+	0x8d, 0x80, 0x39, 0x93, 0x21, 0x73, 0x56, 0x01, 0x1c, 0xcb, 0x76, 0x0f, 0x2c, 0xbb, 0x4d, 0xec,
+	0x6a, 0x66, 0x41, 0x5b, 0x2c, 0x2f, 0xdf, 0x5b, 0x52, 0x17, 0x62, 0x49, 0x35, 0x68, 0x69, 0xcf,
+	0xb2, 0xdd, 0x1d, 0xca, 0xab, 0xe7, 0x1d, 0xf9, 0x89, 0x3e, 0x84, 0x02, 0x13, 0xe2, 0x1a, 0xf6,
+	0x31, 0x71, 0xab, 0x59, 0x26, 0xe5, 0xfe, 0x05, 0x52, 0x9a, 0x8c, 0x59, 0x67, 0xea, 0xf9, 0x37,
+	0xc2, 0x50, 0x74, 0x88, 0xdd, 0x31, 0xba, 0x9d, 0x37, 0xc6, 0x61, 0x97, 0x54, 0x73, 0x0b, 0xda,
+	0xe2, 0x94, 0x1e, 0xa0, 0xd1, 0xf9, 0x9f, 0x92, 0x73, 0xe7, 0xc0, 0x32, 0xbb, 0xe7, 0xd5, 0x29,
+	0xc6, 0x30, 0x45, 0x09, 0x3b, 0x66, 0xf7, 0x9c, 0x2d, 0x9a, 0x35, 0x30, 0x5d, 0xde, 0x9b, 0x67,
+	0xbd, 0x79, 0x46, 0x61, 0xdd, 0x8b, 0x50, 0xe9, 0x75, 0xcc, 0x83, 0x9e, 0xd5, 0x3e, 0xf0, 0x1c,
+	0x02, 0xcc, 0x21, 0xe5, 0x5e, 0xc7, 0x7c, 0x69, 0xb5, 0x75, 0xe9, 0x16, 0xca, 0x69, 0x9c, 0x05,
+	0x39, 0x0b, 0x82, 0xd3, 0x38, 0x53, 0x39, 0x97, 0x60, 0x86, 0xca, 0x6c, 0xd9, 0xc4, 0x70, 0x89,
+	0xcf, 0x5c, 0x64, 0xcc, 0x57, 0x7a, 0x1d, 0x73, 0x95, 0xf5, 0x04, 0xf8, 0x8d, 0xb3, 0x08, 0x7f,
+	0x49, 0xf0, 0x1b, 0x67, 0x41, 0x7e, 0xbc, 0x04, 0x79, 0xcf, 0xe7, 0x68, 0x0a, 0x26, 0xb7, 0x77,
+	0xb6, 0x1b, 0x95, 0x09, 0x04, 0x90, 0x5d, 0xd9, 0x5b, 0x6d, 0x6c, 0xaf, 0x55, 0x34, 0x54, 0x80,
+	0xdc, 0x5a, 0x83, 0x37, 0x52, 0xf8, 0x39, 0x80, 0xef, 0x5d, 0x94, 0x83, 0xf4, 0x66, 0xe3, 0xcf,
+	0x2a, 0x13, 0x94, 0xe7, 0x55, 0x43, 0xdf, 0xdb, 0xd8, 0xd9, 0xae, 0x68, 0x74, 0xf0, 0xaa, 0xde,
+	0x58, 0x69, 0x36, 0x2a, 0x29, 0xca, 0xf1, 0x72, 0x67, 0xad, 0x92, 0x46, 0x79, 0xc8, 0xbc, 0x5a,
+	0xd9, 0xda, 0x6f, 0x54, 0x26, 0xf1, 0x57, 0x1a, 0x94, 0xc4, 0x7a, 0xf1, 0x98, 0x40, 0xef, 0x41,
+	0xf6, 0x84, 0xc5, 0x05, 0xdb, 0x8a, 0x85, 0xe5, 0x9b, 0xa1, 0xc5, 0x0d, 0xc4, 0x8e, 0x2e, 0x78,
+	0x11, 0x86, 0xf4, 0xe9, 0xd0, 0xa9, 0xa6, 0x16, 0xd2, 0x8b, 0x85, 0xe5, 0xca, 0x12, 0x0f, 0xd8,
+	0xa5, 0x4d, 0x72, 0xfe, 0xca, 0xe8, 0x0e, 0x88, 0x4e, 0x3b, 0x11, 0x82, 0xc9, 0x9e, 0x65, 0x13,
+	0xb6, 0x63, 0xa7, 0x74, 0xf6, 0x4d, 0xb7, 0x31, 0x5b, 0x34, 0xb1, 0x5b, 0x79, 0x03, 0x7f, 0xab,
+	0x01, 0xec, 0x0e, 0xdc, 0xe4, 0xd0, 0x98, 0x85, 0xcc, 0x90, 0x0a, 0x16, 0x61, 0xc1, 0x1b, 0x2c,
+	0x26, 0x88, 0xe1, 0x10, 0x2f, 0x26, 0x68, 0x03, 0x5d, 0x87, 0x5c, 0xdf, 0x26, 0xc3, 0x83, 0xd3,
+	0x21, 0x53, 0x32, 0xa5, 0x67, 0x69, 0x73, 0x73, 0x88, 0xee, 0x40, 0xb1, 0x73, 0x6c, 0x5a, 0x36,
+	0x39, 0xe0, 0xb2, 0x32, 0xac, 0xb7, 0xc0, 0x69, 0xcc, 0x6e, 0x85, 0x85, 0x0b, 0xce, 0xaa, 0x2c,
+	0x5b, 0x94, 0x84, 0x4d, 0x28, 0x30, 0x53, 0xc7, 0x72, 0xdf, 0x23, 0xdf, 0xc6, 0x14, 0x1b, 0x16,
+	0x75, 0xa1, 0xb0, 0x1a, 0x7f, 0x06, 0x68, 0x8d, 0x74, 0x89, 0x4b, 0xc6, 0xc9, 0x1e, 0x8a, 0x4f,
+	0xd2, 0xaa, 0x4f, 0xf0, 0x3f, 0x6b, 0x30, 0x13, 0x10, 0x3f, 0xd6, 0xb4, 0xaa, 0x90, 0x6b, 0x33,
+	0x61, 0xdc, 0x82, 0xb4, 0x2e, 0x9b, 0xe8, 0x09, 0x4c, 0x09, 0x03, 0x9c, 0x6a, 0x3a, 0x61, 0xd3,
+	0xe4, 0xb8, 0x4d, 0x0e, 0xfe, 0x36, 0x05, 0x79, 0x31, 0xd1, 0x9d, 0x3e, 0x5a, 0x81, 0x92, 0xcd,
+	0x1b, 0x07, 0x6c, 0x3e, 0xc2, 0xa2, 0x5a, 0x72, 0x12, 0x5a, 0x9f, 0xd0, 0x8b, 0x62, 0x08, 0x23,
+	0xa3, 0x3f, 0x81, 0x82, 0x14, 0xd1, 0x1f, 0xb8, 0xc2, 0xe5, 0xd5, 0xa0, 0x00, 0x7f, 0xff, 0xad,
+	0x4f, 0xe8, 0x20, 0xd8, 0x77, 0x07, 0x2e, 0x6a, 0xc2, 0xac, 0x1c, 0xcc, 0x67, 0x23, 0xcc, 0x48,
+	0x33, 0x29, 0x0b, 0x41, 0x29, 0xd1, 0xa5, 0x5a, 0x9f, 0xd0, 0x91, 0x18, 0xaf, 0x74, 0xaa, 0x26,
+	0xb9, 0x67, 0x3c, 0x79, 0x47, 0x4c, 0x6a, 0x9e, 0x99, 0x51, 0x93, 0x9a, 0x67, 0xe6, 0xf3, 0x3c,
+	0xe4, 0x44, 0x0b, 0xff, 0x57, 0x0a, 0x40, 0xae, 0xc6, 0x4e, 0x1f, 0xad, 0x41, 0xd9, 0x16, 0xad,
+	0x80, 0xb7, 0x6e, 0xc4, 0x7a, 0x4b, 0x2c, 0xe2, 0x84, 0x5e, 0x92, 0x83, 0xb8, 0x71, 0xef, 0x43,
+	0xd1, 0x93, 0xe2, 0x3b, 0x6c, 0x2e, 0xc6, 0x61, 0x9e, 0x84, 0x82, 0x1c, 0x40, 0x5d, 0xf6, 0x09,
+	0x5c, 0xf5, 0xc6, 0xc7, 0xf8, 0xec, 0xce, 0x08, 0x9f, 0x79, 0x02, 0x67, 0xa4, 0x04, 0xd5, 0x6b,
+	0xaa, 0x61, 0xbe, 0xdb, 0xe6, 0x62, 0xdc, 0x16, 0x35, 0x8c, 0x3a, 0x0e, 0x68, 0xbd, 0xe4, 0x4d,
+	0xfc, 0xeb, 0x34, 0xe4, 0x56, 0xad, 0x5e, 0xdf, 0xb0, 0xe9, 0x6a, 0x64, 0x6d, 0xe2, 0x0c, 0xba,
+	0x2e, 0x73, 0x57, 0x79, 0xf9, 0x6e, 0x50, 0xa2, 0x60, 0x93, 0xff, 0xea, 0x8c, 0x55, 0x17, 0x43,
+	0xe8, 0x60, 0x51, 0x1e, 0x53, 0x97, 0x18, 0x2c, 0x8a, 0xa3, 0x18, 0x22, 0x03, 0x39, 0xed, 0x07,
+	0x72, 0x0d, 0x72, 0x43, 0x62, 0xfb, 0x25, 0x7d, 0x7d, 0x42, 0x97, 0x04, 0xf4, 0x08, 0xa6, 0xc3,
+	0xe5, 0x25, 0x23, 0x78, 0xca, 0xad, 0x60, 0x35, 0xba, 0x0b, 0xc5, 0x40, 0x8d, 0xcb, 0x0a, 0xbe,
+	0x42, 0x4f, 0x29, 0x71, 0xd7, 0x64, 0x5e, 0xa5, 0xf5, 0xb8, 0xb8, 0x3e, 0x21, 0x33, 0xeb, 0x35,
+	0x99, 0x59, 0xa7, 0xc4, 0x28, 0x91, 0x5b, 0x03, 0x49, 0xe6, 0x83, 0x60, 0x92, 0xc1, 0x1f, 0x40,
+	0x29, 0xe0, 0x20, 0x5a, 0x77, 0x1a, 0x1f, 0xef, 0xaf, 0x6c, 0xf1, 0x22, 0xf5, 0x82, 0xd5, 0x25,
+	0xbd, 0xa2, 0xd1, 0x5a, 0xb7, 0xd5, 0xd8, 0xdb, 0xab, 0xa4, 0x50, 0x09, 0xf2, 0xdb, 0x3b, 0xcd,
+	0x03, 0xce, 0x95, 0xc6, 0x2f, 0x3c, 0x09, 0xa2, 0xc8, 0x29, 0xb5, 0x6d, 0x42, 0xa9, 0x6d, 0x9a,
+	0xac, 0x6d, 0x29, 0xbf, 0xb6, 0xb1, 0x32, 0xb7, 0xd5, 0x58, 0xd9, 0x6b, 0x54, 0x26, 0x9f, 0x97,
+	0xa1, 0xc8, 0xfd, 0x7b, 0x30, 0x30, 0x69, 0xa9, 0xfd, 0x77, 0x0d, 0xc0, 0x8f, 0x26, 0x54, 0x87,
+	0x5c, 0x8b, 0xeb, 0xa9, 0x6a, 0x2c, 0x19, 0x5d, 0x8d, 0x5d, 0x32, 0x5d, 0x72, 0xa1, 0x77, 0x20,
+	0xe7, 0x0c, 0x5a, 0x2d, 0xe2, 0xc8, 0x92, 0x77, 0x3d, 0x9c, 0x0f, 0x45, 0xb6, 0xd2, 0x25, 0x1f,
+	0x1d, 0x72, 0x64, 0x74, 0xba, 0x03, 0x56, 0x00, 0x47, 0x0f, 0x11, 0x7c, 0xf8, 0xdf, 0x34, 0x28,
+	0x28, 0x9b, 0xf7, 0x07, 0x26, 0xe1, 0x9b, 0x90, 0x67, 0x36, 0x90, 0xb6, 0x48, 0xc3, 0x53, 0xba,
+	0x4f, 0x40, 0x7f, 0x0c, 0x79, 0x19, 0x01, 0x32, 0x13, 0x57, 0xe3, 0xc5, 0xee, 0xf4, 0x75, 0x9f,
+	0x15, 0x6f, 0xc2, 0x15, 0xe6, 0x95, 0x16, 0x3d, 0x5c, 0x4b, 0x3f, 0xaa, 0xc7, 0x4f, 0x2d, 0x74,
+	0xfc, 0xac, 0xc1, 0x54, 0xff, 0xe4, 0xdc, 0xe9, 0xb4, 0x8c, 0xae, 0xb0, 0xc2, 0x6b, 0xe3, 0x8f,
+	0x00, 0xa9, 0xc2, 0xc6, 0x99, 0x2e, 0x2e, 0x41, 0x61, 0xdd, 0x70, 0x4e, 0x84, 0x49, 0xf8, 0x09,
+	0x94, 0x68, 0x73, 0xf3, 0xd5, 0x25, 0x6c, 0x64, 0x97, 0x03, 0xc9, 0x3d, 0x96, 0xcf, 0x11, 0x4c,
+	0x9e, 0x18, 0xce, 0x09, 0x9b, 0x68, 0x49, 0x67, 0xdf, 0xe8, 0x11, 0x54, 0x5a, 0x7c, 0x92, 0x07,
+	0xa1, 0x2b, 0xc3, 0xb4, 0xa0, 0x7b, 0x27, 0xc1, 0x4f, 0xa1, 0xc8, 0xe7, 0xf0, 0x63, 0x1b, 0x81,
+	0xaf, 0xc0, 0xf4, 0x9e, 0x69, 0xf4, 0x9d, 0x13, 0x4b, 0x56, 0x37, 0x3a, 0xe9, 0x8a, 0x4f, 0x1b,
+	0x4b, 0xe3, 0x43, 0x98, 0xb6, 0x49, 0xcf, 0xe8, 0x98, 0x1d, 0xf3, 0xf8, 0xe0, 0xf0, 0xdc, 0x25,
+	0x8e, 0xb8, 0x30, 0x95, 0x3d, 0xf2, 0x73, 0x4a, 0xa5, 0xa6, 0x1d, 0x76, 0xad, 0x43, 0x91, 0xe6,
+	0xd8, 0x37, 0xfe, 0x4f, 0x0d, 0x8a, 0x9f, 0x18, 0x6e, 0x4b, 0x2e, 0x1d, 0xda, 0x80, 0xb2, 0x97,
+	0xdc, 0x18, 0x45, 0xd8, 0x12, 0x2a, 0xb1, 0x6c, 0x8c, 0x3c, 0x4a, 0xcb, 0xea, 0x58, 0x6a, 0xa9,
+	0x04, 0x26, 0xca, 0x30, 0x5b, 0xa4, 0xeb, 0x89, 0x4a, 0x25, 0x8b, 0x62, 0x8c, 0xaa, 0x28, 0x95,
+	0xf0, 0x7c, 0xda, 0x3f, 0x7e, 0xf0, 0x5c, 0xf2, 0x75, 0x0a, 0x50, 0xd4, 0x86, 0xef, 0x7b, 0x22,
+	0xbb, 0x0f, 0x65, 0xc7, 0x35, 0xec, 0xc8, 0xde, 0x28, 0x31, 0xaa, 0x97, 0xa0, 0x1f, 0xc2, 0x74,
+	0xdf, 0xb6, 0x8e, 0x6d, 0xe2, 0x38, 0x07, 0xa6, 0xe5, 0x76, 0x8e, 0xce, 0xc5, 0xa1, 0xb6, 0x2c,
+	0xc9, 0xdb, 0x8c, 0x8a, 0x1a, 0x90, 0x3b, 0xea, 0x74, 0x5d, 0x62, 0x3b, 0xd5, 0xcc, 0x42, 0x7a,
+	0xb1, 0xbc, 0xfc, 0xe4, 0x22, 0xaf, 0x2d, 0x7d, 0xc8, 0xf8, 0x9b, 0xe7, 0x7d, 0xa2, 0xcb, 0xb1,
+	0xea, 0x41, 0x31, 0x1b, 0x38, 0x28, 0xde, 0x07, 0xf0, 0xf9, 0x69, 0xaa, 0xdd, 0xde, 0xd9, 0xdd,
+	0x6f, 0x56, 0x26, 0x50, 0x11, 0xa6, 0xb6, 0x77, 0xd6, 0x1a, 0x5b, 0x0d, 0x9a, 0x97, 0x71, 0x5d,
+	0xfa, 0x46, 0xf5, 0x21, 0x9a, 0x83, 0xa9, 0xd7, 0x94, 0x2a, 0xef, 0xdb, 0x69, 0x3d, 0xc7, 0xda,
+	0x1b, 0x6d, 0xfc, 0x4f, 0x29, 0x28, 0x89, 0x5d, 0x30, 0xd6, 0x56, 0x54, 0x55, 0xa4, 0x02, 0x2a,
+	0xe8, 0xa9, 0x94, 0xef, 0x8e, 0xb6, 0x38, 0xfc, 0xca, 0x26, 0xcd, 0x0d, 0x7c, 0xb1, 0x49, 0x5b,
+	0xb8, 0xd5, 0x6b, 0xc7, 0x86, 0x6f, 0x26, 0x36, 0x7c, 0xd1, 0x5d, 0x28, 0x79, 0xbb, 0xcd, 0x70,
+	0x44, 0xad, 0xcd, 0xeb, 0x45, 0xb9, 0x91, 0x28, 0x0d, 0xdd, 0x87, 0x2c, 0x19, 0x12, 0xd3, 0x75,
+	0xaa, 0x05, 0x96, 0x75, 0x4b, 0xf2, 0xfc, 0xdb, 0xa0, 0x54, 0x5d, 0x74, 0xe2, 0x3f, 0x82, 0x2b,
+	0xec, 0x9e, 0xf1, 0xc2, 0x36, 0x4c, 0xf5, 0x42, 0xd4, 0x6c, 0x6e, 0x09, 0xd7, 0xd1, 0x4f, 0x54,
+	0x86, 0xd4, 0xc6, 0x9a, 0x98, 0x68, 0x6a, 0x63, 0x0d, 0x7f, 0xa1, 0x01, 0x52, 0xc7, 0x8d, 0xe5,
+	0xcb, 0x90, 0x70, 0xa9, 0x3e, 0xed, 0xab, 0x9f, 0x85, 0x0c, 0xb1, 0x6d, 0xcb, 0x66, 0x5e, 0xcb,
+	0xeb, 0xbc, 0x81, 0xef, 0x09, 0x1b, 0x74, 0x32, 0xb4, 0x4e, 0xbd, 0xc0, 0xe0, 0xd2, 0x34, 0xcf,
+	0xd4, 0x4d, 0x98, 0x09, 0x70, 0x8d, 0x95, 0xfd, 0x1f, 0xc2, 0x55, 0x26, 0x6c, 0x93, 0x90, 0xfe,
+	0x4a, 0xb7, 0x33, 0x4c, 0xd4, 0xda, 0x87, 0x6b, 0x61, 0xc6, 0x9f, 0xd6, 0x47, 0xf8, 0x4f, 0x85,
+	0xc6, 0x66, 0xa7, 0x47, 0x9a, 0xd6, 0x56, 0xb2, 0x6d, 0x34, 0x3b, 0x9e, 0x92, 0x73, 0x47, 0x94,
+	0x49, 0xf6, 0x8d, 0xff, 0x43, 0x83, 0xeb, 0x91, 0xe1, 0x3f, 0xf1, 0xaa, 0xce, 0x03, 0x1c, 0xd3,
+	0xed, 0x43, 0xda, 0xb4, 0x83, 0xdf, 0xd0, 0x15, 0x8a, 0x67, 0x27, 0x4d, 0x30, 0x45, 0x61, 0xe7,
+	0xac, 0x58, 0x73, 0xf6, 0xc7, 0x91, 0x35, 0xe6, 0x16, 0x14, 0x18, 0x61, 0xcf, 0x35, 0xdc, 0x81,
+	0x13, 0x59, 0x8c, 0xbf, 0x11, 0x5b, 0x40, 0x0e, 0x1a, 0x6b, 0x5e, 0xef, 0x40, 0x96, 0x1d, 0x4e,
+	0xe5, 0xd1, 0x2c, 0x74, 0x1b, 0x50, 0xec, 0xd0, 0x05, 0x23, 0x3e, 0x81, 0xec, 0x4b, 0x86, 0xe8,
+	0x29, 0x96, 0x4d, 0xca, 0xa5, 0x30, 0x8d, 0x1e, 0xc7, 0x19, 0xf2, 0x3a, 0xfb, 0x66, 0x27, 0x19,
+	0x42, 0xec, 0x7d, 0x7d, 0x8b, 0x9f, 0x98, 0xf2, 0xba, 0xd7, 0xa6, 0x2e, 0x6b, 0x75, 0x3b, 0xc4,
+	0x74, 0x59, 0xef, 0x24, 0xeb, 0x55, 0x28, 0x78, 0x09, 0x2a, 0x5c, 0xd3, 0x4a, 0xbb, 0xad, 0x9c,
+	0x48, 0x3c, 0x79, 0x5a, 0x50, 0x1e, 0xfe, 0x46, 0x83, 0x2b, 0xca, 0x80, 0xb1, 0x1c, 0xf3, 0x14,
+	0xb2, 0x1c, 0xb7, 0x14, 0xc5, 0x6f, 0x36, 0x38, 0x8a, 0xab, 0xd1, 0x05, 0x0f, 0x5a, 0x82, 0x1c,
+	0xff, 0x92, 0xc7, 0xc2, 0x78, 0x76, 0xc9, 0x84, 0xef, 0xc3, 0x8c, 0x20, 0x91, 0x9e, 0x15, 0xb7,
+	0xb7, 0x99, 0x43, 0xf1, 0xe7, 0x30, 0x1b, 0x64, 0x1b, 0x6b, 0x4a, 0x8a, 0x91, 0xa9, 0xcb, 0x18,
+	0xb9, 0x22, 0x8d, 0xdc, 0xef, 0xb7, 0x95, 0x5a, 0x1d, 0x5e, 0x75, 0x75, 0x45, 0x52, 0xa1, 0x15,
+	0xf1, 0x26, 0x20, 0x45, 0xfc, 0xac, 0x13, 0x98, 0x91, 0xdb, 0x61, 0xab, 0xe3, 0x78, 0x27, 0xb8,
+	0x37, 0x80, 0x54, 0xe2, 0xcf, 0x6d, 0xd0, 0x1a, 0x39, 0xb2, 0x8d, 0xe3, 0x1e, 0xf1, 0xea, 0x13,
+	0x3d, 0xcf, 0xab, 0xc4, 0xb1, 0x32, 0x7a, 0x1d, 0xae, 0xbc, 0xb4, 0x86, 0x34, 0x35, 0x50, 0xaa,
+	0x1f, 0x32, 0xfc, 0x3e, 0xe7, 0x2d, 0x9b, 0xd7, 0xa6, 0xca, 0xd5, 0x01, 0x63, 0x29, 0xff, 0x5f,
+	0x0d, 0x8a, 0x2b, 0x5d, 0xc3, 0xee, 0x49, 0xc5, 0xef, 0x43, 0x96, 0xdf, 0x52, 0x04, 0x30, 0xf0,
+	0x20, 0x28, 0x46, 0xe5, 0xe5, 0x8d, 0x15, 0x7e, 0xa7, 0x11, 0xa3, 0xa8, 0xe1, 0xe2, 0xed, 0x60,
+	0x2d, 0xf4, 0x96, 0xb0, 0x86, 0xde, 0x82, 0x8c, 0x41, 0x87, 0xb0, 0x14, 0x5c, 0x0e, 0xdf, 0x0f,
+	0x99, 0x34, 0x76, 0x38, 0xe3, 0x5c, 0xf8, 0x3d, 0x28, 0x28, 0x1a, 0xe8, 0x0d, 0xf8, 0x45, 0x43,
+	0x1c, 0xc0, 0x56, 0x56, 0x9b, 0x1b, 0xaf, 0xf8, 0xc5, 0xb8, 0x0c, 0xb0, 0xd6, 0xf0, 0xda, 0x29,
+	0xfc, 0xa9, 0x18, 0x25, 0xf2, 0x9d, 0x6a, 0x8f, 0x96, 0x64, 0x4f, 0xea, 0x52, 0xf6, 0x9c, 0x41,
+	0x49, 0x4c, 0x7f, 0xdc, 0xf4, 0xcd, 0xe4, 0x25, 0xa4, 0x6f, 0xc5, 0x78, 0x5d, 0x30, 0xe2, 0x69,
+	0x28, 0x89, 0x84, 0x2e, 0xf6, 0xdf, 0xff, 0x68, 0x50, 0x96, 0x94, 0x71, 0x01, 0x4c, 0x89, 0xbd,
+	0xf0, 0x0a, 0xe0, 0x21, 0x2f, 0xd7, 0x20, 0xdb, 0x3e, 0xdc, 0xeb, 0xbc, 0x91, 0x60, 0xb3, 0x68,
+	0x51, 0x7a, 0x97, 0xeb, 0xe1, 0x2f, 0x3e, 0xa2, 0x45, 0x6f, 0xe1, 0xb6, 0x71, 0xe4, 0x6e, 0x98,
+	0x6d, 0x72, 0xc6, 0xce, 0x8d, 0x93, 0xba, 0x4f, 0x60, 0x97, 0x52, 0xf1, 0x32, 0xc4, 0x0e, 0x8b,
+	0xea, 0x4b, 0xd1, 0x0c, 0x5c, 0x59, 0x19, 0xb8, 0x27, 0x0d, 0xd3, 0x38, 0xec, 0xca, 0x8c, 0x45,
+	0xcb, 0x2c, 0x25, 0xae, 0x75, 0x1c, 0x95, 0xda, 0x80, 0x19, 0x4a, 0x25, 0xa6, 0xdb, 0x69, 0x29,
+	0xe9, 0x4d, 0x16, 0x31, 0x2d, 0x54, 0xc4, 0x0c, 0xc7, 0x79, 0x6d, 0xd9, 0x6d, 0x31, 0x35, 0xaf,
+	0x8d, 0xd7, 0xb8, 0xf0, 0x7d, 0x27, 0x50, 0xa6, 0xbe, 0xaf, 0x94, 0x45, 0x5f, 0xca, 0x0b, 0xe2,
+	0x8e, 0x90, 0x82, 0x9f, 0xc0, 0x55, 0xc9, 0x29, 0xc0, 0xbd, 0x11, 0xcc, 0x3b, 0x70, 0x4b, 0x32,
+	0xaf, 0x9e, 0xd0, 0xdb, 0xd3, 0xae, 0x50, 0xf8, 0x43, 0xed, 0x7c, 0x0e, 0x55, 0xcf, 0x4e, 0x76,
+	0x58, 0xb6, 0xba, 0xaa, 0x01, 0x03, 0x47, 0xec, 0x99, 0xbc, 0xce, 0xbe, 0x29, 0xcd, 0xb6, 0xba,
+	0xde, 0x91, 0x80, 0x7e, 0xe3, 0x55, 0x98, 0x93, 0x32, 0xc4, 0x31, 0x36, 0x28, 0x24, 0x62, 0x50,
+	0x9c, 0x10, 0xe1, 0x30, 0x3a, 0x74, 0xb4, 0xdb, 0x55, 0xce, 0xa0, 0x6b, 0x99, 0x4c, 0x4d, 0x91,
+	0x79, 0x95, 0xef, 0x08, 0x6a, 0x98, 0x5a, 0x31, 0x04, 0x99, 0x0a, 0x50, 0xc9, 0x62, 0x21, 0x28,
+	0x39, 0xb2, 0x10, 0x11, 0xd1, 0x9f, 0xc1, 0xbc, 0x67, 0x04, 0xf5, 0xdb, 0x2e, 0xb1, 0x7b, 0x1d,
+	0xc7, 0x51, 0xe0, 0xa0, 0xb8, 0x89, 0x3f, 0x80, 0xc9, 0x3e, 0x11, 0x39, 0xa5, 0xb0, 0x8c, 0x96,
+	0xf8, 0xfb, 0xed, 0x92, 0x32, 0x98, 0xf5, 0xe3, 0x36, 0xdc, 0x96, 0xd2, 0xb9, 0x47, 0x63, 0xc5,
+	0x87, 0x8d, 0x92, 0xb7, 0x6e, 0xee, 0xd6, 0xe8, 0xad, 0x3b, 0xcd, 0xd7, 0xde, 0x83, 0x28, 0x3f,
+	0xe2, 0x8e, 0x94, 0xb1, 0x35, 0x56, 0xad, 0xd8, 0xe4, 0x3e, 0xf5, 0x42, 0x72, 0x2c, 0x61, 0x87,
+	0x30, 0x1b, 0x8c, 0xe4, 0xb1, 0xd2, 0xd8, 0x2c, 0x64, 0x5c, 0xeb, 0x94, 0xc8, 0x24, 0xc6, 0x1b,
+	0xd2, 0x60, 0x2f, 0xcc, 0xc7, 0x32, 0xd8, 0xf0, 0x85, 0xb1, 0x2d, 0x39, 0xae, 0xbd, 0x74, 0x35,
+	0xe5, 0xe1, 0x8b, 0x37, 0xf0, 0x36, 0x5c, 0x0b, 0xa7, 0x89, 0xb1, 0x4c, 0x7e, 0xc5, 0x37, 0x70,
+	0x5c, 0x26, 0x19, 0x4b, 0xee, 0xc7, 0x7e, 0x32, 0x50, 0x12, 0xca, 0x58, 0x22, 0x75, 0xa8, 0xc5,
+	0xe5, 0x97, 0x1f, 0x63, 0xbf, 0x7a, 0xe9, 0x66, 0x2c, 0x61, 0x8e, 0x2f, 0x6c, 0xfc, 0xe5, 0xf7,
+	0x73, 0x44, 0x7a, 0x64, 0x8e, 0x10, 0x41, 0xe2, 0x67, 0xb1, 0x9f, 0x60, 0xd3, 0x09, 0x1d, 0x7e,
+	0x02, 0x1d, 0x57, 0x07, 0xad, 0x21, 0x9e, 0x0e, 0xd6, 0x90, 0x1b, 0x5b, 0x4d, 0xbb, 0x63, 0x2d,
+	0xc6, 0x27, 0x7e, 0xee, 0x8c, 0x64, 0xe6, 0xb1, 0x04, 0x7f, 0x0a, 0x0b, 0xc9, 0x49, 0x79, 0x1c,
+	0xc9, 0x8f, 0xeb, 0x90, 0xf7, 0x0e, 0x94, 0xca, 0x6f, 0x1f, 0x0a, 0x90, 0xdb, 0xde, 0xd9, 0xdb,
+	0x5d, 0x59, 0x6d, 0xf0, 0x1f, 0x3f, 0xac, 0xee, 0xe8, 0xfa, 0xfe, 0x6e, 0xb3, 0x92, 0x5a, 0xfe,
+	0x6d, 0x1a, 0x52, 0x9b, 0xaf, 0xd0, 0x9f, 0x43, 0x86, 0xbf, 0x04, 0x8e, 0x78, 0xfe, 0xad, 0x8d,
+	0x7a, 0xec, 0xc4, 0x37, 0xbe, 0xf8, 0xff, 0x5f, 0x7d, 0x95, 0xba, 0x8a, 0x2b, 0xf5, 0xe1, 0xbb,
+	0x87, 0xc4, 0x35, 0xea, 0xa7, 0xc3, 0x3a, 0xab, 0x0f, 0xcf, 0xb4, 0xc7, 0x68, 0x1f, 0xd2, 0xbb,
+	0x03, 0x17, 0x25, 0x3e, 0x0d, 0xd7, 0x92, 0xdf, 0x40, 0xf1, 0x1c, 0x13, 0x3c, 0x83, 0xcb, 0x8a,
+	0xe0, 0xfe, 0xc0, 0xa5, 0x62, 0x07, 0x50, 0x50, 0x5f, 0x31, 0x2f, 0x7c, 0x33, 0xae, 0x5d, 0xfc,
+	0x42, 0x8a, 0xef, 0x30, 0x75, 0x37, 0xf0, 0x35, 0x45, 0x1d, 0x7f, 0x6b, 0x55, 0x67, 0xd3, 0x3c,
+	0x33, 0x51, 0xe2, 0xab, 0x72, 0x2d, 0xf9, 0xe1, 0x34, 0x76, 0x36, 0xee, 0x99, 0x49, 0xc5, 0x9a,
+	0xe2, 0xdd, 0xb4, 0xe5, 0xa2, 0xdb, 0x31, 0xef, 0x66, 0xea, 0x0b, 0x51, 0x6d, 0x21, 0x99, 0x41,
+	0x28, 0x5a, 0x60, 0x8a, 0x6a, 0xf8, 0xaa, 0xa2, 0xa8, 0xe5, 0xb1, 0x3d, 0xd3, 0x1e, 0x2f, 0x1f,
+	0x43, 0x86, 0x21, 0xc4, 0xe8, 0x2f, 0xe4, 0x47, 0x2d, 0x06, 0xdb, 0x4e, 0x58, 0xfc, 0x00, 0xb6,
+	0x8c, 0xab, 0x4c, 0x19, 0xc2, 0x25, 0xa9, 0x8c, 0x61, 0xc4, 0xcf, 0xb4, 0xc7, 0x8b, 0xda, 0xdb,
+	0xda, 0xf2, 0x6f, 0x26, 0x21, 0xc3, 0xe0, 0x22, 0x64, 0x01, 0xf8, 0x68, 0x6a, 0x78, 0x96, 0x11,
+	0x7c, 0x36, 0x3c, 0xcb, 0x28, 0x10, 0x8b, 0xe7, 0x99, 0xe2, 0x2a, 0x9e, 0x91, 0x8a, 0x19, 0x12,
+	0x55, 0x67, 0xe0, 0x1a, 0xf5, 0xe9, 0x50, 0x00, 0x66, 0x3c, 0xcc, 0x50, 0x9c, 0xc0, 0x00, 0xaa,
+	0x1a, 0xde, 0x21, 0x31, 0x88, 0x2a, 0xc6, 0x4c, 0xe7, 0x4d, 0x7c, 0x5d, 0xf1, 0x2c, 0x57, 0x6b,
+	0x33, 0x46, 0xaa, 0xf7, 0xef, 0x34, 0x28, 0x07, 0x71, 0x51, 0x74, 0x37, 0x46, 0x72, 0x18, 0x5e,
+	0xad, 0xdd, 0x1b, 0xcd, 0x94, 0x64, 0x01, 0x57, 0x7f, 0x4a, 0x48, 0xdf, 0xa0, 0x8c, 0xc2, 0xf1,
+	0xe8, 0x1f, 0x34, 0x98, 0x0e, 0x81, 0x9d, 0x28, 0x4e, 0x43, 0x04, 0x4a, 0xad, 0xdd, 0xbf, 0x80,
+	0x4b, 0x18, 0xf2, 0x80, 0x19, 0xb2, 0x80, 0x6f, 0x44, 0x5c, 0xe1, 0x76, 0x7a, 0xc4, 0xb5, 0x84,
+	0x31, 0xde, 0x32, 0x70, 0x60, 0x32, 0x76, 0x19, 0x02, 0x40, 0x67, 0xec, 0x32, 0x04, 0x51, 0xcd,
+	0x11, 0xcb, 0xc0, 0xd1, 0x48, 0xba, 0xc5, 0x7f, 0x97, 0x86, 0xdc, 0x2a, 0xff, 0x05, 0x22, 0x72,
+	0x20, 0xef, 0x21, 0x80, 0x68, 0x3e, 0x0e, 0x8d, 0xf1, 0x6f, 0x0b, 0xb5, 0xdb, 0x89, 0xfd, 0x42,
+	0xfb, 0x7d, 0xa6, 0xfd, 0x36, 0xae, 0x49, 0xed, 0xe2, 0x87, 0x8e, 0x75, 0x7e, 0xed, 0xaf, 0x1b,
+	0xed, 0x36, 0x9d, 0xf8, 0xdf, 0x42, 0x51, 0x85, 0xe9, 0xd0, 0x9d, 0x58, 0x14, 0x48, 0x45, 0xfa,
+	0x6a, 0x78, 0x14, 0x8b, 0xd0, 0xbe, 0xc8, 0xb4, 0x63, 0x7c, 0x2b, 0x41, 0xbb, 0xcd, 0xd8, 0x03,
+	0x06, 0x70, 0x98, 0x2d, 0xde, 0x80, 0x00, 0x8a, 0x17, 0x6f, 0x40, 0x10, 0xa5, 0xbb, 0xd0, 0x80,
+	0x01, 0x63, 0xa7, 0x06, 0xbc, 0x06, 0xf0, 0x41, 0x35, 0x14, 0xeb, 0x57, 0xe5, 0xea, 0x14, 0x0e,
+	0xf9, 0x28, 0x1e, 0x17, 0xdd, 0x73, 0x21, 0xd5, 0xdd, 0x8e, 0x43, 0x43, 0x7f, 0xf9, 0x9b, 0x2c,
+	0x14, 0x5e, 0x1a, 0x1d, 0xd3, 0x25, 0xa6, 0x61, 0xb6, 0x08, 0x3a, 0x82, 0x0c, 0x2b, 0x8d, 0xe1,
+	0x2c, 0xa7, 0x62, 0x4d, 0xe1, 0x2c, 0x17, 0x00, 0x62, 0xf0, 0x3d, 0xa6, 0x79, 0x1e, 0xcf, 0x49,
+	0xcd, 0x3d, 0x5f, 0x7c, 0x9d, 0x61, 0x28, 0x74, 0xc2, 0x7f, 0x09, 0x59, 0x01, 0xcf, 0x87, 0x84,
+	0x05, 0xb0, 0x95, 0xda, 0xcd, 0xf8, 0xce, 0xa4, 0xed, 0xa5, 0xaa, 0x72, 0x18, 0x2f, 0xd5, 0xf5,
+	0x06, 0xc0, 0x07, 0x08, 0xc3, 0xce, 0x8d, 0xe0, 0x89, 0xb5, 0x85, 0x64, 0x06, 0xa1, 0xf7, 0x11,
+	0xd3, 0x7b, 0x17, 0xcf, 0xc7, 0xe9, 0x6d, 0x7b, 0xfc, 0x54, 0xf7, 0x21, 0x4c, 0xae, 0x1b, 0xce,
+	0x09, 0x0a, 0x15, 0x3b, 0xe5, 0x47, 0x03, 0xb5, 0x5a, 0x5c, 0x97, 0xd0, 0x74, 0x97, 0x69, 0xba,
+	0x85, 0xab, 0x71, 0x9a, 0x4e, 0x0c, 0x87, 0x56, 0x0f, 0x74, 0x02, 0x59, 0xfe, 0x3b, 0x82, 0xb0,
+	0x2f, 0x03, 0xbf, 0x45, 0x08, 0xfb, 0x32, 0xf8, 0xd3, 0x83, 0xcb, 0x69, 0x72, 0x61, 0x4a, 0x3e,
+	0xde, 0xa3, 0x5b, 0xa1, 0xa5, 0x09, 0x3e, 0xf4, 0xd7, 0xe6, 0x93, 0xba, 0x85, 0xbe, 0x87, 0x4c,
+	0xdf, 0x1d, 0x7c, 0x33, 0x76, 0xed, 0x04, 0xf7, 0x33, 0xed, 0xf1, 0xdb, 0x1a, 0x2d, 0x13, 0xe0,
+	0x83, 0xac, 0x91, 0xe8, 0x08, 0xe3, 0xb5, 0x91, 0xe8, 0x88, 0xe0, 0xb3, 0x78, 0x99, 0x29, 0x7f,
+	0x8a, 0x1f, 0xc6, 0x29, 0x77, 0x6d, 0xc3, 0x74, 0x8e, 0x88, 0xfd, 0x16, 0x07, 0xd3, 0x9c, 0x93,
+	0x4e, 0x9f, 0x46, 0xca, 0xef, 0xa7, 0x61, 0x92, 0x9e, 0x47, 0x69, 0x79, 0xf6, 0xaf, 0xf1, 0x61,
+	0x6b, 0x22, 0xe0, 0x59, 0xd8, 0x9a, 0x28, 0x02, 0x10, 0x2d, 0xcf, 0xec, 0xb7, 0xe6, 0x84, 0x31,
+	0x51, 0xaf, 0x3b, 0x50, 0x50, 0xee, 0xfa, 0x28, 0x46, 0x60, 0x10, 0x99, 0x0b, 0xd7, 0x85, 0x18,
+	0xa0, 0x00, 0xdf, 0x66, 0x3a, 0xe7, 0xf0, 0x6c, 0x40, 0x67, 0x9b, 0x73, 0x51, 0xa5, 0x7f, 0x0d,
+	0x45, 0x15, 0x13, 0x40, 0x31, 0x32, 0x43, 0xc8, 0x5f, 0x38, 0x25, 0xc6, 0x41, 0x0a, 0xd1, 0xec,
+	0xe0, 0xfd, 0xae, 0x5e, 0xb2, 0x52, 0xe5, 0x7d, 0xc8, 0x09, 0xa0, 0x20, 0x6e, 0xb6, 0x41, 0xa8,
+	0x30, 0x6e, 0xb6, 0x21, 0x94, 0x21, 0x7a, 0xcc, 0x63, 0x5a, 0xe9, 0x7d, 0x48, 0x96, 0x20, 0xa1,
+	0xf1, 0x05, 0x71, 0x93, 0x34, 0xfa, 0xd8, 0x57, 0x92, 0x46, 0xe5, 0x2e, 0x3a, 0x4a, 0xe3, 0x31,
+	0x71, 0x45, 0x2c, 0xc9, 0x7b, 0x1e, 0x4a, 0x10, 0xa8, 0xa6, 0x7c, 0x3c, 0x8a, 0x25, 0xe9, 0x54,
+	0xee, 0x2b, 0x15, 0xf9, 0x1e, 0x7d, 0x0e, 0xe0, 0x43, 0x1a, 0xe1, 0xd3, 0x56, 0x2c, 0x2e, 0x1a,
+	0x3e, 0x6d, 0xc5, 0xa3, 0x22, 0xd1, 0xfc, 0xe1, 0xeb, 0xe6, 0x17, 0x03, 0xaa, 0xfd, 0x5f, 0x34,
+	0x40, 0x51, 0x04, 0x04, 0x3d, 0x89, 0xd7, 0x10, 0x8b, 0xb8, 0xd6, 0x9e, 0x5e, 0x8e, 0x39, 0xa9,
+	0x44, 0xf8, 0x66, 0xb5, 0xd8, 0x88, 0xfe, 0x6b, 0x6a, 0xd8, 0x97, 0x1a, 0x94, 0x02, 0x10, 0x0a,
+	0x7a, 0x90, 0xb0, 0xc6, 0x21, 0xd0, 0xb6, 0xf6, 0xf0, 0x42, 0xbe, 0xa4, 0x93, 0x98, 0xb2, 0x23,
+	0xe4, 0x41, 0xfc, 0x1f, 0x35, 0x28, 0x07, 0x61, 0x17, 0x94, 0x20, 0x3f, 0x02, 0xfc, 0xd6, 0x16,
+	0x2f, 0x66, 0xbc, 0x78, 0xa9, 0xfc, 0xb3, 0x79, 0x1f, 0x72, 0x02, 0xac, 0x89, 0x0b, 0x88, 0x20,
+	0x6c, 0x1c, 0x17, 0x10, 0x21, 0xa4, 0x27, 0x21, 0x20, 0x6c, 0xab, 0x4b, 0x94, 0x10, 0x14, 0x88,
+	0x4e, 0x92, 0xc6, 0xd1, 0x21, 0x18, 0x82, 0x83, 0x46, 0x69, 0xf4, 0x43, 0x50, 0xc2, 0x39, 0x28,
+	0x41, 0xe0, 0x05, 0x21, 0x18, 0x46, 0x83, 0x12, 0x42, 0x90, 0x29, 0x55, 0x42, 0xd0, 0x07, 0x5f,
+	0xe2, 0x42, 0x30, 0x82, 0x88, 0xc7, 0x85, 0x60, 0x14, 0xbf, 0x49, 0x58, 0x57, 0xa6, 0x3b, 0x10,
+	0x82, 0x33, 0x31, 0x58, 0x0d, 0x7a, 0x9a, 0xe0, 0xd0, 0x58, 0xb0, 0xbd, 0xf6, 0xd6, 0x25, 0xb9,
+	0x47, 0xee, 0x7d, 0xbe, 0x14, 0x72, 0xef, 0x7f, 0xad, 0xc1, 0x6c, 0x1c, 0xd6, 0x83, 0x12, 0x74,
+	0x25, 0x00, 0xf5, 0xb5, 0xa5, 0xcb, 0xb2, 0x5f, 0xec, 0x35, 0x2f, 0x1a, 0x9e, 0x57, 0xfe, 0xfb,
+	0xbb, 0x79, 0xed, 0xff, 0xbe, 0x9b, 0xd7, 0x7e, 0xf1, 0xdd, 0xbc, 0xf6, 0xaf, 0xbf, 0x9c, 0x9f,
+	0x38, 0xcc, 0xb2, 0xff, 0xe1, 0xf5, 0xee, 0x1f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x74, 0x55, 0x61,
+	0xe6, 0x68, 0x36, 0x00, 0x00,
 }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.proto b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.proto
index a6cd00ab7c3..e80e6e7d0b5 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.proto
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.proto
@@ -15,7 +15,7 @@ service KV {
   // Range gets the keys in the range from the key-value store.
   rpc Range(RangeRequest) returns (RangeResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/kv/range"
+        post: "/v3beta/kv/range"
         body: "*"
     };
   }
@@ -25,7 +25,7 @@ service KV {
   // and generates one event in the event history.
   rpc Put(PutRequest) returns (PutResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/kv/put"
+        post: "/v3beta/kv/put"
         body: "*"
     };
   }
@@ -35,7 +35,7 @@ service KV {
   // and generates a delete event in the event history for every deleted key.
   rpc DeleteRange(DeleteRangeRequest) returns (DeleteRangeResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/kv/deleterange"
+        post: "/v3beta/kv/deleterange"
         body: "*"
     };
   }
@@ -46,7 +46,7 @@ service KV {
   // It is not allowed to modify the same key several times within one txn.
   rpc Txn(TxnRequest) returns (TxnResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/kv/txn"
+        post: "/v3beta/kv/txn"
         body: "*"
     };
   }
@@ -56,7 +56,7 @@ service KV {
   // indefinitely.
   rpc Compact(CompactionRequest) returns (CompactionResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/kv/compaction"
+        post: "/v3beta/kv/compaction"
         body: "*"
     };
   }
@@ -70,7 +70,7 @@ service Watch {
   // last compaction revision.
   rpc Watch(stream WatchRequest) returns (stream WatchResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/watch"
+        post: "/v3beta/watch"
         body: "*"
     };
   }
@@ -82,7 +82,7 @@ service Lease {
   // deleted if the lease expires. Each expired key generates a delete event in the event history.
   rpc LeaseGrant(LeaseGrantRequest) returns (LeaseGrantResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/lease/grant"
+        post: "/v3beta/lease/grant"
         body: "*"
     };
   }
@@ -90,7 +90,7 @@ service Lease {
   // LeaseRevoke revokes a lease. All keys attached to the lease will expire and be deleted.
   rpc LeaseRevoke(LeaseRevokeRequest) returns (LeaseRevokeResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/kv/lease/revoke"
+        post: "/v3beta/kv/lease/revoke"
         body: "*"
     };
   }
@@ -99,7 +99,7 @@ service Lease {
   // to the server and streaming keep alive responses from the server to the client.
   rpc LeaseKeepAlive(stream LeaseKeepAliveRequest) returns (stream LeaseKeepAliveResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/lease/keepalive"
+        post: "/v3beta/lease/keepalive"
         body: "*"
     };
   }
@@ -107,19 +107,25 @@ service Lease {
   // LeaseTimeToLive retrieves lease information.
   rpc LeaseTimeToLive(LeaseTimeToLiveRequest) returns (LeaseTimeToLiveResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/kv/lease/timetolive"
+        post: "/v3beta/kv/lease/timetolive"
         body: "*"
     };
   }
 
-  // TODO(xiangli) List all existing Leases?
+  // LeaseLeases lists all existing leases.
+  rpc LeaseLeases(LeaseLeasesRequest) returns (LeaseLeasesResponse) {
+      option (google.api.http) = {
+        post: "/v3beta/kv/lease/leases"
+        body: "*"
+    };
+  }
 }
 
 service Cluster {
   // MemberAdd adds a member into the cluster.
   rpc MemberAdd(MemberAddRequest) returns (MemberAddResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/cluster/member/add"
+        post: "/v3beta/cluster/member/add"
         body: "*"
     };
   }
@@ -127,7 +133,7 @@ service Cluster {
   // MemberRemove removes an existing member from the cluster.
   rpc MemberRemove(MemberRemoveRequest) returns (MemberRemoveResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/cluster/member/remove"
+        post: "/v3beta/cluster/member/remove"
         body: "*"
     };
   }
@@ -135,7 +141,7 @@ service Cluster {
   // MemberUpdate updates the member configuration.
   rpc MemberUpdate(MemberUpdateRequest) returns (MemberUpdateResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/cluster/member/update"
+        post: "/v3beta/cluster/member/update"
         body: "*"
     };
   }
@@ -143,7 +149,7 @@ service Cluster {
   // MemberList lists all the members in the cluster.
   rpc MemberList(MemberListRequest) returns (MemberListResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/cluster/member/list"
+        post: "/v3beta/cluster/member/list"
         body: "*"
     };
   }
@@ -153,7 +159,7 @@ service Maintenance {
   // Alarm activates, deactivates, and queries alarms regarding cluster health.
   rpc Alarm(AlarmRequest) returns (AlarmResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/maintenance/alarm"
+        post: "/v3beta/maintenance/alarm"
         body: "*"
     };
   }
@@ -161,7 +167,7 @@ service Maintenance {
   // Status gets the status of the member.
   rpc Status(StatusRequest) returns (StatusResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/maintenance/status"
+        post: "/v3beta/maintenance/status"
         body: "*"
     };
   }
@@ -169,17 +175,25 @@ service Maintenance {
   // Defragment defragments a member's backend database to recover storage space.
   rpc Defragment(DefragmentRequest) returns (DefragmentResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/maintenance/defragment"
+        post: "/v3beta/maintenance/defragment"
         body: "*"
     };
   }
 
-  // Hash returns the hash of the local KV state for consistency checking purpose.
+  // Hash computes the hash of the KV's backend.
   // This is designed for testing; do not use this in production when there
   // are ongoing transactions.
   rpc Hash(HashRequest) returns (HashResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/maintenance/hash"
+        post: "/v3beta/maintenance/hash"
+        body: "*"
+    };
+  }
+
+  // HashKV computes the hash of all MVCC keys up to a given revision.
+  rpc HashKV(HashKVRequest) returns (HashKVResponse) {
+      option (google.api.http) = {
+        post: "/v3beta/maintenance/hash"
         body: "*"
     };
   }
@@ -187,7 +201,15 @@ service Maintenance {
   // Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
   rpc Snapshot(SnapshotRequest) returns (stream SnapshotResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/maintenance/snapshot"
+        post: "/v3beta/maintenance/snapshot"
+        body: "*"
+    };
+  }
+
+  // MoveLeader requests current leader node to transfer its leadership to transferee.
+  rpc MoveLeader(MoveLeaderRequest) returns (MoveLeaderResponse) {
+      option (google.api.http) = {
+        post: "/v3beta/maintenance/transfer-leadership"
         body: "*"
     };
   }
@@ -197,7 +219,7 @@ service Auth {
   // AuthEnable enables authentication.
   rpc AuthEnable(AuthEnableRequest) returns (AuthEnableResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/enable"
+        post: "/v3beta/auth/enable"
         body: "*"
     };
   }
@@ -205,7 +227,7 @@ service Auth {
   // AuthDisable disables authentication.
   rpc AuthDisable(AuthDisableRequest) returns (AuthDisableResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/disable"
+        post: "/v3beta/auth/disable"
         body: "*"
     };
   }
@@ -213,7 +235,7 @@ service Auth {
   // Authenticate processes an authenticate request.
   rpc Authenticate(AuthenticateRequest) returns (AuthenticateResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/authenticate"
+        post: "/v3beta/auth/authenticate"
         body: "*"
     };
   }
@@ -221,7 +243,7 @@ service Auth {
   // UserAdd adds a new user.
   rpc UserAdd(AuthUserAddRequest) returns (AuthUserAddResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/user/add"
+        post: "/v3beta/auth/user/add"
         body: "*"
     };
   }
@@ -229,7 +251,7 @@ service Auth {
   // UserGet gets detailed user information.
   rpc UserGet(AuthUserGetRequest) returns (AuthUserGetResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/user/get"
+        post: "/v3beta/auth/user/get"
         body: "*"
     };
   }
@@ -237,7 +259,7 @@ service Auth {
   // UserList gets a list of all users.
   rpc UserList(AuthUserListRequest) returns (AuthUserListResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/user/list"
+        post: "/v3beta/auth/user/list"
         body: "*"
     };
   }
@@ -245,7 +267,7 @@ service Auth {
   // UserDelete deletes a specified user.
   rpc UserDelete(AuthUserDeleteRequest) returns (AuthUserDeleteResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/user/delete"
+        post: "/v3beta/auth/user/delete"
         body: "*"
     };
   }
@@ -253,7 +275,7 @@ service Auth {
   // UserChangePassword changes the password of a specified user.
   rpc UserChangePassword(AuthUserChangePasswordRequest) returns (AuthUserChangePasswordResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/user/changepw"
+        post: "/v3beta/auth/user/changepw"
         body: "*"
     };
   }
@@ -261,7 +283,7 @@ service Auth {
   // UserGrant grants a role to a specified user.
   rpc UserGrantRole(AuthUserGrantRoleRequest) returns (AuthUserGrantRoleResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/user/grant"
+        post: "/v3beta/auth/user/grant"
         body: "*"
     };
   }
@@ -269,7 +291,7 @@ service Auth {
   // UserRevokeRole revokes a role of specified user.
   rpc UserRevokeRole(AuthUserRevokeRoleRequest) returns (AuthUserRevokeRoleResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/user/revoke"
+        post: "/v3beta/auth/user/revoke"
         body: "*"
     };
   }
@@ -277,7 +299,7 @@ service Auth {
   // RoleAdd adds a new role.
   rpc RoleAdd(AuthRoleAddRequest) returns (AuthRoleAddResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/role/add"
+        post: "/v3beta/auth/role/add"
         body: "*"
     };
   }
@@ -285,7 +307,7 @@ service Auth {
   // RoleGet gets detailed role information.
   rpc RoleGet(AuthRoleGetRequest) returns (AuthRoleGetResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/role/get"
+        post: "/v3beta/auth/role/get"
         body: "*"
     };
   }
@@ -293,7 +315,7 @@ service Auth {
   // RoleList gets lists of all roles.
   rpc RoleList(AuthRoleListRequest) returns (AuthRoleListResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/role/list"
+        post: "/v3beta/auth/role/list"
         body: "*"
     };
   }
@@ -301,7 +323,7 @@ service Auth {
   // RoleDelete deletes a specified role.
   rpc RoleDelete(AuthRoleDeleteRequest) returns (AuthRoleDeleteResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/role/delete"
+        post: "/v3beta/auth/role/delete"
         body: "*"
     };
   }
@@ -309,7 +331,7 @@ service Auth {
   // RoleGrantPermission grants a permission of a specified key or range to a specified role.
   rpc RoleGrantPermission(AuthRoleGrantPermissionRequest) returns (AuthRoleGrantPermissionResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/role/grant"
+        post: "/v3beta/auth/role/grant"
         body: "*"
     };
   }
@@ -317,7 +339,7 @@ service Auth {
   // RoleRevokePermission revokes a key or range permission of a specified role.
   rpc RoleRevokePermission(AuthRoleRevokePermissionRequest) returns (AuthRoleRevokePermissionResponse) {
       option (google.api.http) = {
-        post: "/v3alpha/auth/role/revoke"
+        post: "/v3beta/auth/role/revoke"
         body: "*"
     };
   }
@@ -380,7 +402,7 @@ message RangeRequest {
 
   // keys_only when set returns only the keys and not the values.
   bool keys_only = 8;
- 
+
   // count_only when set returns only the count of the keys in the range.
   bool count_only = 9;
 
@@ -469,6 +491,7 @@ message RequestOp {
     RangeRequest request_range = 1;
     PutRequest request_put = 2;
     DeleteRangeRequest request_delete_range = 3;
+    TxnRequest request_txn = 4;
   }
 }
 
@@ -478,6 +501,7 @@ message ResponseOp {
     RangeResponse response_range = 1;
     PutResponse response_put = 2;
     DeleteRangeResponse response_delete_range = 3;
+    TxnResponse response_txn = 4;
   }
 }
 
@@ -493,6 +517,7 @@ message Compare {
     CREATE = 1;
     MOD = 2;
     VALUE= 3;
+    LEASE = 4;
   }
   // result is logical comparison operation for this comparison.
   CompareResult result = 1;
@@ -509,7 +534,15 @@ message Compare {
     int64 mod_revision = 6;
     // value is the value of the given key, in bytes.
     bytes value = 7;
+    // lease is the lease id of the given key.
+    int64 lease = 8;
+    // leave room for more target_union field tags, jump to 64
   }
+
+  // range_end compares the given target to all keys in the range [key, range_end).
+  // See RangeRequest for more details on key ranges.
+  bytes range_end = 64;
+  // TODO: fill out with most of the rest of RangeRequest fields when needed.
 }
 
 // From google paxosdb paper:
@@ -552,7 +585,7 @@ message TxnResponse {
 // CompactionRequest compacts the key-value store up to a given revision. All superseded keys
 // with a revision less than the compaction revision will be removed.
 message CompactionRequest {
-  // revision is the key-value store revision for the compaction operation. 
+  // revision is the key-value store revision for the compaction operation.
   int64 revision = 1;
   // physical is set so the RPC will wait until the compaction is physically
   // applied to the local database such that compacted entries are totally
@@ -567,9 +600,22 @@ message CompactionResponse {
 message HashRequest {
 }
 
+message HashKVRequest {
+  // revision is the key-value store revision for the hash operation.
+  int64 revision = 1;
+}
+
+message HashKVResponse {
+  ResponseHeader header = 1;
+  // hash is the hash value computed from the responding member's MVCC keys up to a given revision.
+  uint32 hash = 2;
+  // compact_revision is the compacted revision of key-value store when hash begins.
+  int64 compact_revision = 3;
+}
+
 message HashResponse {
   ResponseHeader header = 1;
-  // hash is the hash value computed from the responding member's key-value store.
+  // hash is the hash value computed from the responding member's KV's backend.
   uint32 hash = 2;
 }
 
@@ -648,7 +694,7 @@ message WatchResponse {
   // at a compacted index.
   //
   // This happens when creating a watcher at a compacted revision or the watcher cannot
-  // catch up with the progress of the key-value store. 
+  // catch up with the progress of the key-value store.
   //
   // The client should treat the watcher as canceled and should not try to create any
   // watcher with the same start_revision again.
@@ -661,7 +707,7 @@ message WatchResponse {
 }
 
 message LeaseGrantRequest {
-  // TTL is the advisory time-to-live in seconds.
+  // TTL is the advisory time-to-live in seconds. Expired lease will return -1.
   int64 TTL = 1;
   // ID is the requested ID for the lease. If ID is set to 0, the lessor chooses an ID.
   int64 ID = 2;
@@ -717,6 +763,19 @@ message LeaseTimeToLiveResponse {
   repeated bytes keys = 5;
 }
 
+message LeaseLeasesRequest {
+}
+
+message LeaseStatus {
+  int64 ID = 1;
+  // TODO: int64 TTL = 2;
+}
+
+message LeaseLeasesResponse {
+  ResponseHeader header = 1;
+  repeated LeaseStatus leases = 2;
+}
+
 message Member {
   // ID is the member ID for this member.
   uint64 ID = 1;
@@ -781,9 +840,19 @@ message DefragmentResponse {
   ResponseHeader header = 1;
 }
 
+message MoveLeaderRequest {
+  // targetID is the node ID for the new leader.
+  uint64 targetID = 1;
+}
+
+message MoveLeaderResponse {
+  ResponseHeader header = 1;
+}
+
 enum AlarmType {
 	NONE = 0; // default, used to query if any alarm is active
 	NOSPACE = 1; // space quota is exhausted
+	CORRUPT = 2; // kv store corruption detected
 }
 
 message AlarmRequest {
diff --git a/vendor/github.com/coreos/etcd/etcdserver/membership/BUILD b/vendor/github.com/coreos/etcd/etcdserver/membership/BUILD
index a7394569315..e21e67838f7 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/membership/BUILD
+++ b/vendor/github.com/coreos/etcd/etcdserver/membership/BUILD
@@ -23,7 +23,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/version:go_default_library",
         "//vendor/github.com/coreos/go-semver/semver:go_default_library",
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/etcdserver/membership/cluster.go b/vendor/github.com/coreos/etcd/etcdserver/membership/cluster.go
index 2330219f18a..4f0b1572ef6 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/membership/cluster.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/membership/cluster.go
@@ -16,6 +16,7 @@ package membership
 
 import (
 	"bytes"
+	"context"
 	"crypto/sha1"
 	"encoding/binary"
 	"encoding/json"
@@ -26,8 +27,6 @@ import (
 	"sync"
 	"time"
 
-	"golang.org/x/net/context"
-
 	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/pkg/netutil"
 	"github.com/coreos/etcd/pkg/types"
@@ -35,6 +34,7 @@ import (
 	"github.com/coreos/etcd/raft/raftpb"
 	"github.com/coreos/etcd/store"
 	"github.com/coreos/etcd/version"
+
 	"github.com/coreos/go-semver/semver"
 )
 
@@ -490,8 +490,8 @@ func ValidateClusterAndAssignIDs(local *RaftCluster, existing *RaftCluster) erro
 	ctx, cancel := context.WithTimeout(context.TODO(), 30*time.Second)
 	defer cancel()
 	for i := range ems {
-		if !netutil.URLStringsEqual(ctx, ems[i].PeerURLs, lms[i].PeerURLs) {
-			return fmt.Errorf("unmatched member while checking PeerURLs")
+		if ok, err := netutil.URLStringsEqual(ctx, ems[i].PeerURLs, lms[i].PeerURLs); !ok {
+			return fmt.Errorf("unmatched member while checking PeerURLs (%v)", err)
 		}
 		lms[i].ID = ems[i].ID
 	}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/raft.go b/vendor/github.com/coreos/etcd/etcdserver/raft.go
index 5e2ab3d176f..1080633b18b 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/raft.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/raft.go
@@ -393,7 +393,7 @@ func (r *raftNode) advanceTicks(ticks int) {
 	}
 }
 
-func startNode(cfg *ServerConfig, cl *membership.RaftCluster, ids []types.ID) (id types.ID, n raft.Node, s *raft.MemoryStorage, w *wal.WAL) {
+func startNode(cfg ServerConfig, cl *membership.RaftCluster, ids []types.ID) (id types.ID, n raft.Node, s *raft.MemoryStorage, w *wal.WAL) {
 	var err error
 	member := cl.MemberByName(cfg.Name)
 	metadata := pbutil.MustMarshal(
@@ -430,11 +430,10 @@ func startNode(cfg *ServerConfig, cl *membership.RaftCluster, ids []types.ID) (i
 	raftStatusMu.Lock()
 	raftStatus = n.Status
 	raftStatusMu.Unlock()
-
 	return id, n, s, w
 }
 
-func restartNode(cfg *ServerConfig, snapshot *raftpb.Snapshot) (types.ID, *membership.RaftCluster, raft.Node, *raft.MemoryStorage, *wal.WAL) {
+func restartNode(cfg ServerConfig, snapshot *raftpb.Snapshot) (types.ID, *membership.RaftCluster, raft.Node, *raft.MemoryStorage, *wal.WAL) {
 	var walsnap walpb.Snapshot
 	if snapshot != nil {
 		walsnap.Index, walsnap.Term = snapshot.Metadata.Index, snapshot.Metadata.Term
@@ -467,7 +466,7 @@ func restartNode(cfg *ServerConfig, snapshot *raftpb.Snapshot) (types.ID, *membe
 	return id, cl, n, s, w
 }
 
-func restartAsStandaloneNode(cfg *ServerConfig, snapshot *raftpb.Snapshot) (types.ID, *membership.RaftCluster, raft.Node, *raft.MemoryStorage, *wal.WAL) {
+func restartAsStandaloneNode(cfg ServerConfig, snapshot *raftpb.Snapshot) (types.ID, *membership.RaftCluster, raft.Node, *raft.MemoryStorage, *wal.WAL) {
 	var walsnap walpb.Snapshot
 	if snapshot != nil {
 		walsnap.Index, walsnap.Term = snapshot.Metadata.Index, snapshot.Metadata.Term
diff --git a/vendor/github.com/coreos/etcd/etcdserver/server.go b/vendor/github.com/coreos/etcd/etcdserver/server.go
index a8a38129264..f891c862351 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/server.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/server.go
@@ -15,6 +15,7 @@
 package etcdserver
 
 import (
+	"context"
 	"encoding/json"
 	"expvar"
 	"fmt"
@@ -38,6 +39,7 @@ import (
 	"github.com/coreos/etcd/etcdserver/membership"
 	"github.com/coreos/etcd/etcdserver/stats"
 	"github.com/coreos/etcd/lease"
+	"github.com/coreos/etcd/lease/leasehttp"
 	"github.com/coreos/etcd/mvcc"
 	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/pkg/fileutil"
@@ -54,9 +56,9 @@ import (
 	"github.com/coreos/etcd/store"
 	"github.com/coreos/etcd/version"
 	"github.com/coreos/etcd/wal"
+
 	"github.com/coreos/go-semver/semver"
 	"github.com/coreos/pkg/capnslog"
-	"golang.org/x/net/context"
 )
 
 const (
@@ -82,7 +84,8 @@ const (
 	releaseDelayAfterSnapshot = 30 * time.Second
 
 	// maxPendingRevokes is the maximum number of outstanding expired lease revocations.
-	maxPendingRevokes          = 16
+	maxPendingRevokes = 16
+
 	recommendedMaxRequestBytes = 10 * 1024 * 1024
 )
 
@@ -107,29 +110,33 @@ func init() {
 }
 
 type Response struct {
+	Term    uint64
+	Index   uint64
 	Event   *store.Event
 	Watcher store.Watcher
-	err     error
+	Err     error
 }
 
-type Server interface {
-	// Start performs any initialization of the Server necessary for it to
-	// begin serving requests. It must be called before Do or Process.
-	// Start must be non-blocking; any long-running server functionality
-	// should be implemented in goroutines.
-	Start()
-	// Stop terminates the Server and performs any necessary finalization.
-	// Do and Process cannot be called after Stop has been invoked.
-	Stop()
-	// ID returns the ID of the Server.
+type ServerV2 interface {
+	Server
+	// Do takes a V2 request and attempts to fulfill it, returning a Response.
+	Do(ctx context.Context, r pb.Request) (Response, error)
+	stats.Stats
+	ClientCertAuthEnabled() bool
+}
+
+type ServerV3 interface {
+	Server
 	ID() types.ID
+	RaftTimer
+}
+
+func (s *EtcdServer) ClientCertAuthEnabled() bool { return s.Cfg.ClientCertAuthEnabled }
+
+type Server interface {
 	// Leader returns the ID of the leader Server.
 	Leader() types.ID
-	// Do takes a request and attempts to fulfill it, returning a Response.
-	Do(ctx context.Context, r pb.Request) (Response, error)
-	// Process takes a raft message and applies it to the server's raft state
-	// machine, respecting any timeout of the given context.
-	Process(ctx context.Context, m raftpb.Message) error
+
 	// AddMember attempts to add a member into the cluster. It will return
 	// ErrIDRemoved if member ID is removed from the cluster, or return
 	// ErrIDExists if member ID exists in the cluster.
@@ -138,7 +145,6 @@ type Server interface {
 	// return ErrIDRemoved if member ID is removed from the cluster, or return
 	// ErrIDNotFound if member ID is not in the cluster.
 	RemoveMember(ctx context.Context, id uint64) ([]*membership.Member, error)
-
 	// UpdateMember attempts to update an existing member in the cluster. It will
 	// return ErrIDNotFound if the member ID does not exist.
 	UpdateMember(ctx context.Context, updateMemb membership.Member) ([]*membership.Member, error)
@@ -158,6 +164,8 @@ type Server interface {
 	// the leader is etcd 2.0. etcd 2.0 leader will not update clusterVersion since
 	// this feature is introduced post 2.0.
 	ClusterVersion() *semver.Version
+	Cluster() api.Cluster
+	Alarms() []*pb.AlarmMember
 }
 
 // EtcdServer is the production implementation of the Server interface
@@ -169,12 +177,10 @@ type EtcdServer struct {
 	// consistIndex used to hold the offset of current executing entry
 	// It is initialized to 0 before executing any entry.
 	consistIndex consistentIndex // must use atomic operations to access; keep 64-bit aligned.
-	Cfg          *ServerConfig
+	r            raftNode        // uses 64-bit atomics; keep 64-bit aligned.
 
 	readych chan struct{}
-	r       raftNode
-
-	snapCount uint64
+	Cfg     ServerConfig
 
 	w wait.Wait
 
@@ -222,7 +228,7 @@ type EtcdServer struct {
 
 	SyncTicker *time.Ticker
 	// compactor is used to auto-compact the KV.
-	compactor *compactor.Periodic
+	compactor compactor.Compactor
 
 	// peerRt used to send requests (version, lease) to peers.
 	peerRt   http.RoundTripper
@@ -249,7 +255,7 @@ type EtcdServer struct {
 
 // NewServer creates a new EtcdServer from the supplied configuration. The
 // configuration is considered static for the lifetime of the EtcdServer.
-func NewServer(cfg *ServerConfig) (srv *EtcdServer, err error) {
+func NewServer(cfg ServerConfig) (srv *EtcdServer, err error) {
 	st := store.New(StoreClusterPrefix, StoreKeysPrefix)
 
 	var (
@@ -407,7 +413,6 @@ func NewServer(cfg *ServerConfig) (srv *EtcdServer, err error) {
 	srv = &EtcdServer{
 		readych:     make(chan struct{}),
 		Cfg:         cfg,
-		snapCount:   cfg.SnapCount,
 		errorc:      make(chan error, 1),
 		store:       st,
 		snapshotter: ss,
@@ -471,12 +476,15 @@ func NewServer(cfg *ServerConfig) (srv *EtcdServer, err error) {
 		return nil, err
 	}
 	srv.authStore = auth.NewAuthStore(srv.be, tp)
-	if h := cfg.AutoCompactionRetention; h != 0 {
-		srv.compactor = compactor.NewPeriodic(h, srv.kv, srv)
+	if num := cfg.AutoCompactionRetention; num != 0 {
+		srv.compactor, err = compactor.New(cfg.AutoCompactionMode, num, srv.kv, srv)
+		if err != nil {
+			return nil, err
+		}
 		srv.compactor.Run()
 	}
 
-	srv.applyV3Base = &applierV3backend{srv}
+	srv.applyV3Base = srv.newApplierV3Backend()
 	if err = srv.restoreAlarms(); err != nil {
 		return nil, err
 	}
@@ -568,15 +576,16 @@ func (s *EtcdServer) Start() {
 	s.goAttach(func() { monitorFileDescriptor(s.stopping) })
 	s.goAttach(s.monitorVersions)
 	s.goAttach(s.linearizableReadLoop)
+	s.goAttach(s.monitorKVHash)
 }
 
 // start prepares and starts server in a new goroutine. It is no longer safe to
 // modify a server's fields after it has been sent to Start.
 // This function is just used for testing.
 func (s *EtcdServer) start() {
-	if s.snapCount == 0 {
+	if s.Cfg.SnapCount == 0 {
 		plog.Infof("set snapshot count to default %d", DefaultSnapCount)
-		s.snapCount = DefaultSnapCount
+		s.Cfg.SnapCount = DefaultSnapCount
 	}
 	s.w = wait.New()
 	s.applyWait = wait.NewTimeList()
@@ -619,14 +628,27 @@ func (s *EtcdServer) purgeFile() {
 
 func (s *EtcdServer) ID() types.ID { return s.id }
 
-func (s *EtcdServer) Cluster() *membership.RaftCluster { return s.cluster }
-
-func (s *EtcdServer) RaftHandler() http.Handler { return s.r.transport.Handler() }
-
-func (s *EtcdServer) Lessor() lease.Lessor { return s.lessor }
+func (s *EtcdServer) Cluster() api.Cluster { return s.cluster }
 
 func (s *EtcdServer) ApplyWait() <-chan struct{} { return s.applyWait.Wait(s.getCommittedIndex()) }
 
+type ServerPeer interface {
+	ServerV2
+	RaftHandler() http.Handler
+	LeaseHandler() http.Handler
+}
+
+func (s *EtcdServer) LeaseHandler() http.Handler {
+	if s.lessor == nil {
+		return nil
+	}
+	return leasehttp.NewHandler(s.lessor, s.ApplyWait)
+}
+
+func (s *EtcdServer) RaftHandler() http.Handler { return s.r.transport.Handler() }
+
+// Process takes a raft message and applies it to the server's raft state
+// machine, respecting any timeout of the given context.
 func (s *EtcdServer) Process(ctx context.Context, m raftpb.Message) error {
 	if s.cluster.IsIDRemoved(types.ID(m.From)) {
 		plog.Warningf("reject message from removed member %s", types.ID(m.From).String())
@@ -791,7 +813,8 @@ func (s *EtcdServer) run() {
 					}
 					lid := lease.ID
 					s.goAttach(func() {
-						_, lerr := s.LeaseRevoke(s.ctx, &pb.LeaseRevokeRequest{ID: int64(lid)})
+						ctx := s.authStore.WithRoot(s.ctx)
+						_, lerr := s.LeaseRevoke(ctx, &pb.LeaseRevokeRequest{ID: int64(lid)})
 						if lerr == nil {
 							leaseExpired.Inc()
 						} else {
@@ -957,7 +980,7 @@ func (s *EtcdServer) applyEntries(ep *etcdProgress, apply *apply) {
 }
 
 func (s *EtcdServer) triggerSnapshot(ep *etcdProgress) {
-	if ep.appliedi-ep.snapi <= s.snapCount {
+	if ep.appliedi-ep.snapi <= s.Cfg.SnapCount {
 		return
 	}
 
@@ -974,9 +997,8 @@ func (s *EtcdServer) isLeader() bool {
 	return uint64(s.ID()) == s.Lead()
 }
 
-// transferLeadership transfers the leader to the given transferee.
-// TODO: maybe expose to client?
-func (s *EtcdServer) transferLeadership(ctx context.Context, lead, transferee uint64) error {
+// MoveLeader transfers the leader to the given transferee.
+func (s *EtcdServer) MoveLeader(ctx context.Context, lead, transferee uint64) error {
 	now := time.Now()
 	interval := time.Duration(s.Cfg.TickMs) * time.Millisecond
 
@@ -1015,7 +1037,7 @@ func (s *EtcdServer) TransferLeadership() error {
 
 	tm := s.Cfg.ReqTimeout()
 	ctx, cancel := context.WithTimeout(s.ctx, tm)
-	err := s.transferLeadership(ctx, s.Lead(), uint64(transferee))
+	err := s.MoveLeader(ctx, s.Lead(), uint64(transferee))
 	cancel()
 	return err
 }
@@ -1034,6 +1056,8 @@ func (s *EtcdServer) HardStop() {
 // Stop should be called after a Start(s), otherwise it will block forever.
 // When stopping leader, Stop transfers its leadership to one of its peers
 // before stopping the server.
+// Stop terminates the Server and performs any necessary finalization.
+// Do and Process cannot be called after Stop has been invoked.
 func (s *EtcdServer) Stop() {
 	if err := s.TransferLeadership(); err != nil {
 		plog.Warningf("%s failed to transfer leadership (%v)", s.ID(), err)
@@ -1364,12 +1388,13 @@ func (s *EtcdServer) applyEntryNormal(e *raftpb.Entry) {
 	var raftReq pb.InternalRaftRequest
 	if !pbutil.MaybeUnmarshal(&raftReq, e.Data) { // backward compatible
 		var r pb.Request
-		pbutil.MustUnmarshal(&r, e.Data)
-		s.w.Trigger(r.ID, s.applyV2Request(&r))
+		rp := &r
+		pbutil.MustUnmarshal(rp, e.Data)
+		s.w.Trigger(r.ID, s.applyV2Request((*RequestV2)(rp)))
 		return
 	}
 	if raftReq.V2 != nil {
-		req := raftReq.V2
+		req := (*RequestV2)(raftReq.V2)
 		s.w.Trigger(req.ID, s.applyV2Request(req))
 		return
 	}
@@ -1671,6 +1696,9 @@ func (s *EtcdServer) restoreAlarms() error {
 	if len(as.Get(pb.AlarmType_NOSPACE)) > 0 {
 		s.applyV3 = newApplierV3Capped(s.applyV3)
 	}
+	if len(as.Get(pb.AlarmType_CORRUPT)) > 0 {
+		s.applyV3 = newApplierV3Corrupt(s.applyV3)
+	}
 	return nil
 }
 
@@ -1709,3 +1737,7 @@ func (s *EtcdServer) goAttach(f func()) {
 		f()
 	}()
 }
+
+func (s *EtcdServer) Alarms() []*pb.AlarmMember {
+	return s.alarmStore.Get(pb.AlarmType_NONE)
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/storage.go b/vendor/github.com/coreos/etcd/etcdserver/storage.go
index aa8f87569db..55c2dd4b6a4 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/storage.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/storage.go
@@ -94,5 +94,5 @@ func readWAL(waldir string, snap walpb.Snapshot) (w *wal.WAL, id, cid types.ID,
 	pbutil.MustUnmarshal(&metadata, wmetadata)
 	id = types.ID(metadata.NodeID)
 	cid = types.ID(metadata.ClusterID)
-	return
+	return w, id, cid, st, ents
 }
diff --git a/vendor/github.com/coreos/etcd/etcdserver/v2_server.go b/vendor/github.com/coreos/etcd/etcdserver/v2_server.go
index 72c4eb7c5cc..b458350c10b 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/v2_server.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/v2_server.go
@@ -15,41 +15,86 @@
 package etcdserver
 
 import (
+	"context"
 	"time"
 
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	"golang.org/x/net/context"
+	"github.com/coreos/etcd/store"
 )
 
-type v2API interface {
-	Post(ctx context.Context, r *pb.Request) (Response, error)
-	Put(ctx context.Context, r *pb.Request) (Response, error)
-	Delete(ctx context.Context, r *pb.Request) (Response, error)
-	QGet(ctx context.Context, r *pb.Request) (Response, error)
-	Get(ctx context.Context, r *pb.Request) (Response, error)
-	Head(ctx context.Context, r *pb.Request) (Response, error)
+type RequestV2 pb.Request
+
+type RequestV2Handler interface {
+	Post(ctx context.Context, r *RequestV2) (Response, error)
+	Put(ctx context.Context, r *RequestV2) (Response, error)
+	Delete(ctx context.Context, r *RequestV2) (Response, error)
+	QGet(ctx context.Context, r *RequestV2) (Response, error)
+	Get(ctx context.Context, r *RequestV2) (Response, error)
+	Head(ctx context.Context, r *RequestV2) (Response, error)
 }
 
-type v2apiStore struct{ s *EtcdServer }
+type reqV2HandlerEtcdServer struct {
+	reqV2HandlerStore
+	s *EtcdServer
+}
 
-func (a *v2apiStore) Post(ctx context.Context, r *pb.Request) (Response, error) {
+type reqV2HandlerStore struct {
+	store   store.Store
+	applier ApplierV2
+}
+
+func NewStoreRequestV2Handler(s store.Store, applier ApplierV2) RequestV2Handler {
+	return &reqV2HandlerStore{s, applier}
+}
+
+func (a *reqV2HandlerStore) Post(ctx context.Context, r *RequestV2) (Response, error) {
+	return a.applier.Post(r), nil
+}
+
+func (a *reqV2HandlerStore) Put(ctx context.Context, r *RequestV2) (Response, error) {
+	return a.applier.Put(r), nil
+}
+
+func (a *reqV2HandlerStore) Delete(ctx context.Context, r *RequestV2) (Response, error) {
+	return a.applier.Delete(r), nil
+}
+
+func (a *reqV2HandlerStore) QGet(ctx context.Context, r *RequestV2) (Response, error) {
+	return a.applier.QGet(r), nil
+}
+
+func (a *reqV2HandlerStore) Get(ctx context.Context, r *RequestV2) (Response, error) {
+	if r.Wait {
+		wc, err := a.store.Watch(r.Path, r.Recursive, r.Stream, r.Since)
+		return Response{Watcher: wc}, err
+	}
+	ev, err := a.store.Get(r.Path, r.Recursive, r.Sorted)
+	return Response{Event: ev}, err
+}
+
+func (a *reqV2HandlerStore) Head(ctx context.Context, r *RequestV2) (Response, error) {
+	ev, err := a.store.Get(r.Path, r.Recursive, r.Sorted)
+	return Response{Event: ev}, err
+}
+
+func (a *reqV2HandlerEtcdServer) Post(ctx context.Context, r *RequestV2) (Response, error) {
 	return a.processRaftRequest(ctx, r)
 }
 
-func (a *v2apiStore) Put(ctx context.Context, r *pb.Request) (Response, error) {
+func (a *reqV2HandlerEtcdServer) Put(ctx context.Context, r *RequestV2) (Response, error) {
 	return a.processRaftRequest(ctx, r)
 }
 
-func (a *v2apiStore) Delete(ctx context.Context, r *pb.Request) (Response, error) {
+func (a *reqV2HandlerEtcdServer) Delete(ctx context.Context, r *RequestV2) (Response, error) {
 	return a.processRaftRequest(ctx, r)
 }
 
-func (a *v2apiStore) QGet(ctx context.Context, r *pb.Request) (Response, error) {
+func (a *reqV2HandlerEtcdServer) QGet(ctx context.Context, r *RequestV2) (Response, error) {
 	return a.processRaftRequest(ctx, r)
 }
 
-func (a *v2apiStore) processRaftRequest(ctx context.Context, r *pb.Request) (Response, error) {
-	data, err := r.Marshal()
+func (a *reqV2HandlerEtcdServer) processRaftRequest(ctx context.Context, r *RequestV2) (Response, error) {
+	data, err := ((*pb.Request)(r)).Marshal()
 	if err != nil {
 		return Response{}, err
 	}
@@ -63,7 +108,7 @@ func (a *v2apiStore) processRaftRequest(ctx context.Context, r *pb.Request) (Res
 	select {
 	case x := <-ch:
 		resp := x.(Response)
-		return resp, resp.err
+		return resp, resp.Err
 	case <-ctx.Done():
 		proposalsFailed.Inc()
 		a.s.w.Trigger(r.ID, nil) // GC wait
@@ -73,53 +118,48 @@ func (a *v2apiStore) processRaftRequest(ctx context.Context, r *pb.Request) (Res
 	return Response{}, ErrStopped
 }
 
-func (a *v2apiStore) Get(ctx context.Context, r *pb.Request) (Response, error) {
-	if r.Wait {
-		wc, err := a.s.store.Watch(r.Path, r.Recursive, r.Stream, r.Since)
-		if err != nil {
-			return Response{}, err
-		}
-		return Response{Watcher: wc}, nil
+func (s *EtcdServer) Do(ctx context.Context, r pb.Request) (Response, error) {
+	r.ID = s.reqIDGen.Next()
+	h := &reqV2HandlerEtcdServer{
+		reqV2HandlerStore: reqV2HandlerStore{
+			store:   s.store,
+			applier: s.applyV2,
+		},
+		s: s,
 	}
-	ev, err := a.s.store.Get(r.Path, r.Recursive, r.Sorted)
-	if err != nil {
-		return Response{}, err
-	}
-	return Response{Event: ev}, nil
+	rp := &r
+	resp, err := ((*RequestV2)(rp)).Handle(ctx, h)
+	resp.Term, resp.Index = s.Term(), s.Index()
+	return resp, err
 }
 
-func (a *v2apiStore) Head(ctx context.Context, r *pb.Request) (Response, error) {
-	ev, err := a.s.store.Get(r.Path, r.Recursive, r.Sorted)
-	if err != nil {
-		return Response{}, err
-	}
-	return Response{Event: ev}, nil
-}
-
-// Do interprets r and performs an operation on s.store according to r.Method
+// Handle interprets r and performs an operation on s.store according to r.Method
 // and other fields. If r.Method is "POST", "PUT", "DELETE", or a "GET" with
 // Quorum == true, r will be sent through consensus before performing its
 // respective operation. Do will block until an action is performed or there is
 // an error.
-func (s *EtcdServer) Do(ctx context.Context, r pb.Request) (Response, error) {
-	r.ID = s.reqIDGen.Next()
+func (r *RequestV2) Handle(ctx context.Context, v2api RequestV2Handler) (Response, error) {
 	if r.Method == "GET" && r.Quorum {
 		r.Method = "QGET"
 	}
-	v2api := (v2API)(&v2apiStore{s})
 	switch r.Method {
 	case "POST":
-		return v2api.Post(ctx, &r)
+		return v2api.Post(ctx, r)
 	case "PUT":
-		return v2api.Put(ctx, &r)
+		return v2api.Put(ctx, r)
 	case "DELETE":
-		return v2api.Delete(ctx, &r)
+		return v2api.Delete(ctx, r)
 	case "QGET":
-		return v2api.QGet(ctx, &r)
+		return v2api.QGet(ctx, r)
 	case "GET":
-		return v2api.Get(ctx, &r)
+		return v2api.Get(ctx, r)
 	case "HEAD":
-		return v2api.Head(ctx, &r)
+		return v2api.Head(ctx, r)
 	}
 	return Response{}, ErrUnknownMethod
 }
+
+func (r *RequestV2) String() string {
+	rpb := pb.Request(*r)
+	return rpb.String()
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/v3_server.go b/vendor/github.com/coreos/etcd/etcdserver/v3_server.go
index cff46d57fbc..8d5961bb0c0 100644
--- a/vendor/github.com/coreos/etcd/etcdserver/v3_server.go
+++ b/vendor/github.com/coreos/etcd/etcdserver/v3_server.go
@@ -16,6 +16,7 @@ package etcdserver
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"time"
 
@@ -26,8 +27,8 @@ import (
 	"github.com/coreos/etcd/lease/leasehttp"
 	"github.com/coreos/etcd/mvcc"
 	"github.com/coreos/etcd/raft"
+
 	"github.com/gogo/protobuf/proto"
-	"golang.org/x/net/context"
 )
 
 const (
@@ -58,6 +59,9 @@ type Lessor interface {
 
 	// LeaseTimeToLive retrieves lease information.
 	LeaseTimeToLive(ctx context.Context, r *pb.LeaseTimeToLiveRequest) (*pb.LeaseTimeToLiveResponse, error)
+
+	// LeaseLeases lists all leases.
+	LeaseLeases(ctx context.Context, r *pb.LeaseLeasesRequest) (*pb.LeaseLeasesResponse, error)
 }
 
 type Authenticator interface {
@@ -301,6 +305,15 @@ func (s *EtcdServer) LeaseTimeToLive(ctx context.Context, r *pb.LeaseTimeToLiveR
 	return nil, ErrTimeout
 }
 
+func (s *EtcdServer) LeaseLeases(ctx context.Context, r *pb.LeaseLeasesRequest) (*pb.LeaseLeasesResponse, error) {
+	ls := s.lessor.Leases()
+	lss := make([]*pb.LeaseStatus, len(ls))
+	for i := range ls {
+		lss[i] = &pb.LeaseStatus{ID: int64(ls[i].ID)}
+	}
+	return &pb.LeaseLeasesResponse{Header: newHeader(s), Leases: lss}, nil
+}
+
 func (s *EtcdServer) waitLeader(ctx context.Context) (*membership.Member, error) {
 	leader := s.cluster.Member(s.Leader())
 	for leader == nil {
@@ -694,11 +707,13 @@ func (s *EtcdServer) linearizableReadNotify(ctx context.Context) error {
 }
 
 func (s *EtcdServer) AuthInfoFromCtx(ctx context.Context) (*auth.AuthInfo, error) {
-	if s.Cfg.ClientCertAuthEnabled {
-		authInfo := s.AuthStore().AuthInfoFromTLS(ctx)
-		if authInfo != nil {
-			return authInfo, nil
-		}
+	authInfo, err := s.AuthStore().AuthInfoFromCtx(ctx)
+	if authInfo != nil || err != nil {
+		return authInfo, err
 	}
-	return s.AuthStore().AuthInfoFromCtx(ctx)
+	if !s.Cfg.ClientCertAuthEnabled {
+		return nil, nil
+	}
+	authInfo = s.AuthStore().AuthInfoFromTLS(ctx)
+	return authInfo, nil
 }
diff --git a/vendor/github.com/coreos/etcd/integration/BUILD b/vendor/github.com/coreos/etcd/integration/BUILD
index ef465f1917b..63542770435 100644
--- a/vendor/github.com/coreos/etcd/integration/BUILD
+++ b/vendor/github.com/coreos/etcd/integration/BUILD
@@ -31,8 +31,9 @@ go_library(
         "//vendor/github.com/coreos/etcd/pkg/types:go_default_library",
         "//vendor/github.com/coreos/etcd/rafthttp:go_default_library",
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
+        "//vendor/github.com/soheilhy/cmux:go_default_library",
         "//vendor/google.golang.org/grpc:go_default_library",
+        "//vendor/google.golang.org/grpc/grpclog:go_default_library",
         "//vendor/google.golang.org/grpc/keepalive:go_default_library",
     ],
 )
diff --git a/vendor/github.com/coreos/etcd/integration/bridge.go b/vendor/github.com/coreos/etcd/integration/bridge.go
index 59cebe1f0e0..9792ba89f94 100644
--- a/vendor/github.com/coreos/etcd/integration/bridge.go
+++ b/vendor/github.com/coreos/etcd/integration/bridge.go
@@ -224,5 +224,5 @@ func (b *bridge) ioCopy(bc *bridgeConn, dst io.Writer, src io.Reader) (err error
 			break
 		}
 	}
-	return
+	return err
 }
diff --git a/vendor/github.com/coreos/etcd/integration/cluster.go b/vendor/github.com/coreos/etcd/integration/cluster.go
index 152be0938e4..923e20afa31 100644
--- a/vendor/github.com/coreos/etcd/integration/cluster.go
+++ b/vendor/github.com/coreos/etcd/integration/cluster.go
@@ -15,6 +15,7 @@
 package integration
 
 import (
+	"context"
 	"crypto/tls"
 	"fmt"
 	"io/ioutil"
@@ -51,16 +52,19 @@ import (
 	"github.com/coreos/etcd/rafthttp"
 
 	"github.com/coreos/pkg/capnslog"
-	"golang.org/x/net/context"
+	"github.com/soheilhy/cmux"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/grpclog"
 	"google.golang.org/grpc/keepalive"
 )
 
 const (
-	tickDuration   = 10 * time.Millisecond
-	clusterName    = "etcd"
-	requestTimeout = 20 * time.Second
+	// RequestWaitTimeout is the time duration to wait for a request to go through or detect leader loss.
+	RequestWaitTimeout = 3 * time.Second
+	tickDuration       = 10 * time.Millisecond
+	requestTimeout     = 20 * time.Second
 
+	clusterName  = "etcd"
 	basePort     = 21000
 	UrlScheme    = "unix"
 	UrlSchemeTLS = "unixs"
@@ -97,6 +101,7 @@ type ClusterConfig struct {
 	DiscoveryURL          string
 	UseGRPC               bool
 	QuotaBackendBytes     int64
+	MaxTxnOps             uint
 	MaxRequestBytes       uint
 	GRPCKeepAliveMinTime  time.Duration
 	GRPCKeepAliveInterval time.Duration
@@ -237,6 +242,7 @@ func (c *cluster) mustNewMember(t *testing.T) *member {
 			peerTLS:                  c.cfg.PeerTLS,
 			clientTLS:                c.cfg.ClientTLS,
 			quotaBackendBytes:        c.cfg.QuotaBackendBytes,
+			maxTxnOps:                c.cfg.MaxTxnOps,
 			maxRequestBytes:          c.cfg.MaxRequestBytes,
 			grpcKeepAliveMinTime:     c.cfg.GRPCKeepAliveMinTime,
 			grpcKeepAliveInterval:    c.cfg.GRPCKeepAliveInterval,
@@ -289,10 +295,11 @@ func (c *cluster) addMemberByURL(t *testing.T, clientURL, peerURL string) error
 	cc := MustNewHTTPClient(t, []string{clientURL}, c.cfg.ClientTLS)
 	ma := client.NewMembersAPI(cc)
 	ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
-	if _, err := ma.Add(ctx, peerURL); err != nil {
+	_, err := ma.Add(ctx, peerURL)
+	cancel()
+	if err != nil {
 		return err
 	}
-	cancel()
 
 	// wait for the add node entry applied in the cluster
 	members := append(c.HTTPMembers(), client.Member{PeerURLs: []string{peerURL}, ClientURLs: []string{}})
@@ -315,10 +322,11 @@ func (c *cluster) removeMember(t *testing.T, id uint64) error {
 	cc := MustNewHTTPClient(t, c.URLs(), c.cfg.ClientTLS)
 	ma := client.NewMembersAPI(cc)
 	ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
-	if err := ma.Remove(ctx, types.ID(id).String()); err != nil {
+	err := ma.Remove(ctx, types.ID(id).String())
+	cancel()
+	if err != nil {
 		return err
 	}
-	cancel()
 	newMembers := make([]*member, 0)
 	for _, m := range c.Members {
 		if uint64(m.s.ID()) != id {
@@ -488,12 +496,13 @@ type member struct {
 	// ClientTLSInfo enables client TLS when set
 	ClientTLSInfo *transport.TLSInfo
 
-	raftHandler *testutil.PauseableHandler
-	s           *etcdserver.EtcdServer
-	hss         []*httptest.Server
+	raftHandler   *testutil.PauseableHandler
+	s             *etcdserver.EtcdServer
+	serverClosers []func()
 
 	grpcServerOpts []grpc.ServerOption
 	grpcServer     *grpc.Server
+	grpcServerPeer *grpc.Server
 	grpcAddr       string
 	grpcBridge     *bridge
 
@@ -512,6 +521,7 @@ type memberConfig struct {
 	peerTLS                  *transport.TLSInfo
 	clientTLS                *transport.TLSInfo
 	quotaBackendBytes        int64
+	maxTxnOps                uint
 	maxRequestBytes          uint
 	grpcKeepAliveMinTime     time.Duration
 	grpcKeepAliveInterval    time.Duration
@@ -566,6 +576,10 @@ func mustNewMember(t *testing.T, mcfg memberConfig) *member {
 	m.InitialElectionTickAdvance = true
 	m.TickMs = uint(tickDuration / time.Millisecond)
 	m.QuotaBackendBytes = mcfg.quotaBackendBytes
+	m.MaxTxnOps = mcfg.maxTxnOps
+	if m.MaxTxnOps == 0 {
+		m.MaxTxnOps = embed.DefaultMaxTxnOps
+	}
 	m.MaxRequestBytes = mcfg.maxRequestBytes
 	if m.MaxRequestBytes == 0 {
 		m.MaxRequestBytes = embed.DefaultMaxRequestBytes
@@ -586,10 +600,11 @@ func mustNewMember(t *testing.T, mcfg memberConfig) *member {
 			Timeout: mcfg.grpcKeepAliveTimeout,
 		}))
 	}
-
 	m.clientMaxCallSendMsgSize = mcfg.clientMaxCallSendMsgSize
 	m.clientMaxCallRecvMsgSize = mcfg.clientMaxCallRecvMsgSize
 
+	m.InitialCorruptCheck = true
+
 	return m
 }
 
@@ -611,10 +626,12 @@ func (m *member) listenGRPC() error {
 	return nil
 }
 
-func (m *member) electionTimeout() time.Duration {
-	return time.Duration(m.s.Cfg.ElectionTicks) * time.Millisecond
+func (m *member) ElectionTimeout() time.Duration {
+	return time.Duration(m.s.Cfg.ElectionTicks*int(m.s.Cfg.TickMs)) * time.Millisecond
 }
 
+func (m *member) ID() types.ID { return m.s.ID() }
+
 func (m *member) DropConnections()    { m.grpcBridge.Reset() }
 func (m *member) PauseConnections()   { m.grpcBridge.Pause() }
 func (m *member) UnpauseConnections() { m.grpcBridge.Unpause() }
@@ -681,35 +698,86 @@ func (m *member) Clone(t *testing.T) *member {
 func (m *member) Launch() error {
 	plog.Printf("launching %s (%s)", m.Name, m.grpcAddr)
 	var err error
-	if m.s, err = etcdserver.NewServer(&m.ServerConfig); err != nil {
+	if m.s, err = etcdserver.NewServer(m.ServerConfig); err != nil {
 		return fmt.Errorf("failed to initialize the etcd server: %v", err)
 	}
 	m.s.SyncTicker = time.NewTicker(500 * time.Millisecond)
 	m.s.Start()
 
+	var peerTLScfg *tls.Config
+	if m.PeerTLSInfo != nil && !m.PeerTLSInfo.Empty() {
+		if peerTLScfg, err = m.PeerTLSInfo.ServerConfig(); err != nil {
+			return err
+		}
+	}
+
+	if m.grpcListener != nil {
+		var (
+			tlscfg *tls.Config
+		)
+		if m.ClientTLSInfo != nil && !m.ClientTLSInfo.Empty() {
+			tlscfg, err = m.ClientTLSInfo.ServerConfig()
+			if err != nil {
+				return err
+			}
+		}
+		m.grpcServer = v3rpc.Server(m.s, tlscfg, m.grpcServerOpts...)
+		m.grpcServerPeer = v3rpc.Server(m.s, peerTLScfg)
+		m.serverClient = v3client.New(m.s)
+		lockpb.RegisterLockServer(m.grpcServer, v3lock.NewLockServer(m.serverClient))
+		epb.RegisterElectionServer(m.grpcServer, v3election.NewElectionServer(m.serverClient))
+		go m.grpcServer.Serve(m.grpcListener)
+	}
+
 	m.raftHandler = &testutil.PauseableHandler{Next: etcdhttp.NewPeerHandler(m.s)}
 
+	h := (http.Handler)(m.raftHandler)
+	if m.grpcListener != nil {
+		h = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
+				m.grpcServerPeer.ServeHTTP(w, r)
+			} else {
+				m.raftHandler.ServeHTTP(w, r)
+			}
+		})
+	}
+
 	for _, ln := range m.PeerListeners {
+		cm := cmux.New(ln)
+		// don't hang on matcher after closing listener
+		cm.SetReadTimeout(time.Second)
+
+		if m.grpcServer != nil {
+			grpcl := cm.Match(cmux.HTTP2())
+			go m.grpcServerPeer.Serve(grpcl)
+		}
+
+		// serve http1/http2 rafthttp/grpc
+		ll := cm.Match(cmux.Any())
+		if peerTLScfg != nil {
+			if ll, err = transport.NewTLSListener(ll, m.PeerTLSInfo); err != nil {
+				return err
+			}
+		}
 		hs := &httptest.Server{
-			Listener: ln,
-			Config:   &http.Server{Handler: m.raftHandler},
+			Listener: ll,
+			Config:   &http.Server{Handler: h, TLSConfig: peerTLScfg},
+			TLS:      peerTLScfg,
 		}
-		if m.PeerTLSInfo == nil {
-			hs.Start()
-		} else {
-			info := m.PeerTLSInfo
-			hs.TLS, err = info.ServerConfig()
-			if err != nil {
-				return err
-			}
-			tlsCert, err := tlsutil.NewCert(info.CertFile, info.KeyFile, nil)
-			if err != nil {
-				return err
-			}
-			hs.TLS.Certificates = []tls.Certificate{*tlsCert}
-			hs.StartTLS()
+		hs.Start()
+
+		donec := make(chan struct{})
+		go func() {
+			defer close(donec)
+			cm.Serve()
+		}()
+		closer := func() {
+			ll.Close()
+			hs.CloseClientConnections()
+			hs.Close()
+			<-donec
 		}
-		m.hss = append(m.hss, hs)
+		m.serverClosers = append(m.serverClosers, closer)
 	}
 	for _, ln := range m.ClientListeners {
 		hs := &httptest.Server{
@@ -760,23 +828,12 @@ func (m *member) Launch() error {
 
 			hs.StartTLS()
 		}
-		m.hss = append(m.hss, hs)
-	}
-	if m.grpcListener != nil {
-		var (
-			tlscfg *tls.Config
-		)
-		if m.ClientTLSInfo != nil && !m.ClientTLSInfo.Empty() {
-			tlscfg, err = m.ClientTLSInfo.ServerConfig()
-			if err != nil {
-				return err
-			}
+		closer := func() {
+			ln.Close()
+			hs.CloseClientConnections()
+			hs.Close()
 		}
-		m.grpcServer = v3rpc.Server(m.s, tlscfg, m.grpcServerOpts...)
-		m.serverClient = v3client.New(m.s)
-		lockpb.RegisterLockServer(m.grpcServer, v3lock.NewLockServer(m.serverClient))
-		epb.RegisterElectionServer(m.grpcServer, v3election.NewElectionServer(m.serverClient))
-		go m.grpcServer.Serve(m.grpcListener)
+		m.serverClosers = append(m.serverClosers, closer)
 	}
 
 	plog.Printf("launched %s (%s)", m.Name, m.grpcAddr)
@@ -824,13 +881,16 @@ func (m *member) Close() {
 		m.serverClient = nil
 	}
 	if m.grpcServer != nil {
+		m.grpcServer.Stop()
 		m.grpcServer.GracefulStop()
 		m.grpcServer = nil
+		m.grpcServerPeer.Stop()
+		m.grpcServerPeer.GracefulStop()
+		m.grpcServerPeer = nil
 	}
 	m.s.HardStop()
-	for _, hs := range m.hss {
-		hs.CloseClientConnections()
-		hs.Close()
+	for _, f := range m.serverClosers {
+		f()
 	}
 }
 
@@ -838,7 +898,7 @@ func (m *member) Close() {
 func (m *member) Stop(t *testing.T) {
 	plog.Printf("stopping %s (%s)", m.Name, m.grpcAddr)
 	m.Close()
-	m.hss = nil
+	m.serverClosers = nil
 	plog.Printf("stopped %s (%s)", m.Name, m.grpcAddr)
 }
 
@@ -976,6 +1036,9 @@ type ClusterV3 struct {
 // for each cluster member.
 func NewClusterV3(t *testing.T, cfg *ClusterConfig) *ClusterV3 {
 	cfg.UseGRPC = true
+	if os.Getenv("CLIENT_DEBUG") != "" {
+		clientv3.SetLogger(grpclog.NewLoggerV2WithVerbosity(os.Stderr, os.Stderr, os.Stderr, 4))
+	}
 	clus := &ClusterV3{
 		cluster: NewClusterByConfig(t, cfg),
 	}
diff --git a/vendor/github.com/coreos/etcd/integration/cluster_proxy.go b/vendor/github.com/coreos/etcd/integration/cluster_proxy.go
index 15094358e7b..1e8d8b572fb 100644
--- a/vendor/github.com/coreos/etcd/integration/cluster_proxy.go
+++ b/vendor/github.com/coreos/etcd/integration/cluster_proxy.go
@@ -21,7 +21,6 @@ import (
 
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/clientv3/namespace"
-	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/proxy/grpcproxy"
 	"github.com/coreos/etcd/proxy/grpcproxy/adapter"
 )
@@ -58,6 +57,7 @@ func toGRPC(c *clientv3.Client) grpcAPI {
 	lp, lpch := grpcproxy.NewLeaseProxy(c)
 	mp := grpcproxy.NewMaintenanceProxy(c)
 	clp, _ := grpcproxy.NewClusterProxy(c, "", "") // without registering proxy URLs
+	authp := grpcproxy.NewAuthProxy(c)
 	lockp := grpcproxy.NewLockProxy(c)
 	electp := grpcproxy.NewElectionProxy(c)
 
@@ -67,7 +67,7 @@ func toGRPC(c *clientv3.Client) grpcAPI {
 		adapter.LeaseServerToLeaseClient(lp),
 		adapter.WatchServerToWatchClient(wp),
 		adapter.MaintenanceServerToMaintenanceClient(mp),
-		pb.NewAuthClient(c.ActiveConnection()),
+		adapter.AuthServerToAuthClient(authp),
 		adapter.LockServerToLockClient(lockp),
 		adapter.ElectionServerToElectionClient(electp),
 	}
diff --git a/vendor/github.com/coreos/etcd/lease/BUILD b/vendor/github.com/coreos/etcd/lease/BUILD
index 8d9c58b60c3..e5c6115e347 100644
--- a/vendor/github.com/coreos/etcd/lease/BUILD
+++ b/vendor/github.com/coreos/etcd/lease/BUILD
@@ -12,7 +12,6 @@ go_library(
     deps = [
         "//vendor/github.com/coreos/etcd/lease/leasepb:go_default_library",
         "//vendor/github.com/coreos/etcd/mvcc/backend:go_default_library",
-        "//vendor/github.com/coreos/etcd/pkg/monotime:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/lease/doc.go b/vendor/github.com/coreos/etcd/lease/doc.go
index 73e7d0ec51a..a74eaf76fc5 100644
--- a/vendor/github.com/coreos/etcd/lease/doc.go
+++ b/vendor/github.com/coreos/etcd/lease/doc.go
@@ -12,5 +12,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package lease provides an interface and implemetation for time-limited leases over arbitrary resources.
+// Package lease provides an interface and implementation for time-limited leases over arbitrary resources.
 package lease
diff --git a/vendor/github.com/coreos/etcd/lease/leasehttp/http.go b/vendor/github.com/coreos/etcd/lease/leasehttp/http.go
index c3175cbbb0f..ac2e7880e8a 100644
--- a/vendor/github.com/coreos/etcd/lease/leasehttp/http.go
+++ b/vendor/github.com/coreos/etcd/lease/leasehttp/http.go
@@ -191,7 +191,12 @@ func RenewHTTP(ctx context.Context, id lease.LeaseID, url string, rt http.RoundT
 // TimeToLiveHTTP retrieves lease information of the given lease ID.
 func TimeToLiveHTTP(ctx context.Context, id lease.LeaseID, keys bool, url string, rt http.RoundTripper) (*leasepb.LeaseInternalResponse, error) {
 	// will post lreq protobuf to leader
-	lreq, err := (&leasepb.LeaseInternalRequest{&pb.LeaseTimeToLiveRequest{ID: int64(id), Keys: keys}}).Marshal()
+	lreq, err := (&leasepb.LeaseInternalRequest{
+		LeaseTimeToLiveRequest: &pb.LeaseTimeToLiveRequest{
+			ID:   int64(id),
+			Keys: keys,
+		},
+	}).Marshal()
 	if err != nil {
 		return nil, err
 	}
diff --git a/vendor/github.com/coreos/etcd/lease/leasepb/BUILD b/vendor/github.com/coreos/etcd/lease/leasepb/BUILD
index 8348b7cabf3..5aced32c4bd 100644
--- a/vendor/github.com/coreos/etcd/lease/leasepb/BUILD
+++ b/vendor/github.com/coreos/etcd/lease/leasepb/BUILD
@@ -8,6 +8,7 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//vendor/github.com/coreos/etcd/etcdserver/etcdserverpb:go_default_library",
+        "//vendor/github.com/gogo/protobuf/gogoproto:go_default_library",
         "//vendor/github.com/golang/protobuf/proto:go_default_library",
     ],
 )
diff --git a/vendor/github.com/coreos/etcd/lease/leasepb/lease.pb.go b/vendor/github.com/coreos/etcd/lease/leasepb/lease.pb.go
index ec8db732be5..4ab93767277 100644
--- a/vendor/github.com/coreos/etcd/lease/leasepb/lease.pb.go
+++ b/vendor/github.com/coreos/etcd/lease/leasepb/lease.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: lease.proto
-// DO NOT EDIT!
 
 /*
 	Package leasepb is a generated protocol buffer package.
@@ -22,6 +21,8 @@ import (
 
 	math "math"
 
+	_ "github.com/gogo/protobuf/gogoproto"
+
 	etcdserverpb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
 	io "io"
@@ -155,24 +156,6 @@ func (m *LeaseInternalResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Lease(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Lease(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintLease(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/coreos/etcd/lease/lessor.go b/vendor/github.com/coreos/etcd/lease/lessor.go
index 4bad583393c..43f0503531f 100644
--- a/vendor/github.com/coreos/etcd/lease/lessor.go
+++ b/vendor/github.com/coreos/etcd/lease/lessor.go
@@ -20,25 +20,21 @@ import (
 	"math"
 	"sort"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"github.com/coreos/etcd/lease/leasepb"
 	"github.com/coreos/etcd/mvcc/backend"
-	"github.com/coreos/etcd/pkg/monotime"
 )
 
-const (
-	// NoLease is a special LeaseID representing the absence of a lease.
-	NoLease = LeaseID(0)
-
-	forever = monotime.Time(math.MaxInt64)
-)
+// NoLease is a special LeaseID representing the absence of a lease.
+const NoLease = LeaseID(0)
 
 // MaxLeaseTTL is the maximum lease TTL value
 const MaxLeaseTTL = 9000000000
 
 var (
+	forever = time.Time{}
+
 	leaseBucketName = []byte("lease")
 
 	// maximum number of leases to revoke per second; configurable for tests
@@ -103,6 +99,9 @@ type Lessor interface {
 	// Lookup gives the lease at a given lease id, if any
 	Lookup(id LeaseID) *Lease
 
+	// Leases lists all leases.
+	Leases() []*Lease
+
 	// ExpiredLeasesC returns a chan that is used to receive expired leases.
 	ExpiredLeasesC() <-chan []*Lease
 
@@ -325,6 +324,22 @@ func (le *lessor) Lookup(id LeaseID) *Lease {
 	return le.leaseMap[id]
 }
 
+func (le *lessor) unsafeLeases() []*Lease {
+	leases := make([]*Lease, 0, len(le.leaseMap))
+	for _, l := range le.leaseMap {
+		leases = append(leases, l)
+	}
+	sort.Sort(leasesByExpiry(leases))
+	return leases
+}
+
+func (le *lessor) Leases() []*Lease {
+	le.mu.Lock()
+	ls := le.unsafeLeases()
+	le.mu.Unlock()
+	return ls
+}
+
 func (le *lessor) Promote(extend time.Duration) {
 	le.mu.Lock()
 	defer le.mu.Unlock()
@@ -342,11 +357,7 @@ func (le *lessor) Promote(extend time.Duration) {
 	}
 
 	// adjust expiries in case of overlap
-	leases := make([]*Lease, 0, len(le.leaseMap))
-	for _, l := range le.leaseMap {
-		leases = append(leases, l)
-	}
-	sort.Sort(leasesByExpiry(leases))
+	leases := le.unsafeLeases()
 
 	baseWindow := leases[0].Remaining()
 	nextWindow := baseWindow + time.Second
@@ -471,17 +482,16 @@ func (le *lessor) runLoop() {
 	for {
 		var ls []*Lease
 
+		// rate limit
+		revokeLimit := leaseRevokeRate / 2
+
 		le.mu.Lock()
 		if le.isPrimary() {
-			ls = le.findExpiredLeases()
+			ls = le.findExpiredLeases(revokeLimit)
 		}
 		le.mu.Unlock()
 
 		if len(ls) != 0 {
-			// rate limit
-			if len(ls) > leaseRevokeRate/2 {
-				ls = ls[:leaseRevokeRate/2]
-			}
 			select {
 			case <-le.stopC:
 				return
@@ -501,9 +511,9 @@ func (le *lessor) runLoop() {
 	}
 }
 
-// findExpiredLeases loops all the leases in the leaseMap and returns the expired
-// leases that needed to be revoked.
-func (le *lessor) findExpiredLeases() []*Lease {
+// findExpiredLeases loops leases in the leaseMap until reaching expired limit
+// and returns the expired leases that needed to be revoked.
+func (le *lessor) findExpiredLeases(limit int) []*Lease {
 	leases := make([]*Lease, 0, 16)
 
 	for _, l := range le.leaseMap {
@@ -511,6 +521,11 @@ func (le *lessor) findExpiredLeases() []*Lease {
 		// make up committing latency.
 		if l.expired() {
 			leases = append(leases, l)
+
+			// reach expired limit
+			if len(leases) == limit {
+				break
+			}
 		}
 	}
 
@@ -553,8 +568,10 @@ func (le *lessor) initAndRecover() {
 type Lease struct {
 	ID  LeaseID
 	ttl int64 // time to live in seconds
-	// expiry is time when lease should expire; must be 64-bit aligned.
-	expiry monotime.Time
+	// expiryMu protects concurrent accesses to expiry
+	expiryMu sync.RWMutex
+	// expiry is time when lease should expire. no expiration when expiry.IsZero() is true
+	expiry time.Time
 
 	// mu protects concurrent accesses to itemSet
 	mu      sync.RWMutex
@@ -587,12 +604,18 @@ func (l *Lease) TTL() int64 {
 
 // refresh refreshes the expiry of the lease.
 func (l *Lease) refresh(extend time.Duration) {
-	t := monotime.Now().Add(extend + time.Duration(l.ttl)*time.Second)
-	atomic.StoreUint64((*uint64)(&l.expiry), uint64(t))
+	newExpiry := time.Now().Add(extend + time.Duration(l.ttl)*time.Second)
+	l.expiryMu.Lock()
+	defer l.expiryMu.Unlock()
+	l.expiry = newExpiry
 }
 
 // forever sets the expiry of lease to be forever.
-func (l *Lease) forever() { atomic.StoreUint64((*uint64)(&l.expiry), uint64(forever)) }
+func (l *Lease) forever() {
+	l.expiryMu.Lock()
+	defer l.expiryMu.Unlock()
+	l.expiry = forever
+}
 
 // Keys returns all the keys attached to the lease.
 func (l *Lease) Keys() []string {
@@ -607,8 +630,12 @@ func (l *Lease) Keys() []string {
 
 // Remaining returns the remaining time of the lease.
 func (l *Lease) Remaining() time.Duration {
-	t := monotime.Time(atomic.LoadUint64((*uint64)(&l.expiry)))
-	return time.Duration(t - monotime.Now())
+	l.expiryMu.RLock()
+	defer l.expiryMu.RUnlock()
+	if l.expiry.IsZero() {
+		return time.Duration(math.MaxInt64)
+	}
+	return time.Until(l.expiry)
 }
 
 type LeaseItem struct {
@@ -642,7 +669,9 @@ func (fl *FakeLessor) Demote() {}
 
 func (fl *FakeLessor) Renew(id LeaseID) (int64, error) { return 10, nil }
 
-func (le *FakeLessor) Lookup(id LeaseID) *Lease { return nil }
+func (fl *FakeLessor) Lookup(id LeaseID) *Lease { return nil }
+
+func (fl *FakeLessor) Leases() []*Lease { return nil }
 
 func (fl *FakeLessor) ExpiredLeasesC() <-chan []*Lease { return nil }
 
diff --git a/vendor/github.com/coreos/etcd/mvcc/BUILD b/vendor/github.com/coreos/etcd/mvcc/BUILD
index b0449a5c440..0ac7b55c011 100644
--- a/vendor/github.com/coreos/etcd/mvcc/BUILD
+++ b/vendor/github.com/coreos/etcd/mvcc/BUILD
@@ -32,7 +32,6 @@ go_library(
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
         "//vendor/github.com/google/btree:go_default_library",
         "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/mvcc/backend/backend.go b/vendor/github.com/coreos/etcd/mvcc/backend/backend.go
index a240c8e6280..f7d9e60c2e7 100644
--- a/vendor/github.com/coreos/etcd/mvcc/backend/backend.go
+++ b/vendor/github.com/coreos/etcd/mvcc/backend/backend.go
@@ -147,8 +147,11 @@ func newBackend(bcfg BackendConfig) *backend {
 		batchInterval: bcfg.BatchInterval,
 		batchLimit:    bcfg.BatchLimit,
 
-		readTx: &readTx{buf: txReadBuffer{
-			txBuffer: txBuffer{make(map[string]*bucketBuffer)}},
+		readTx: &readTx{
+			buf: txReadBuffer{
+				txBuffer: txBuffer{make(map[string]*bucketBuffer)},
+			},
+			buckets: make(map[string]*bolt.Bucket),
 		},
 
 		stopc: make(chan struct{}),
@@ -289,7 +292,7 @@ func (b *backend) Defrag() error {
 
 func (b *backend) defrag() error {
 	now := time.Now()
-
+	
 	// TODO: make this non-blocking?
 	// lock batchTx to ensure nobody is using previous tx, and then
 	// close previous ongoing tx.
@@ -345,7 +348,7 @@ func (b *backend) defrag() error {
 		plog.Fatalf("cannot begin tx (%s)", err)
 	}
 
-	b.readTx.buf.reset()
+	b.readTx.reset()
 	b.readTx.tx = b.unsafeBegin(false)
 
 	size := b.readTx.tx.Size()
diff --git a/vendor/github.com/coreos/etcd/mvcc/backend/batch_tx.go b/vendor/github.com/coreos/etcd/mvcc/backend/batch_tx.go
index 4119f2e3065..aed6893e41a 100644
--- a/vendor/github.com/coreos/etcd/mvcc/backend/batch_tx.go
+++ b/vendor/github.com/coreos/etcd/mvcc/backend/batch_tx.go
@@ -16,7 +16,6 @@ package backend
 
 import (
 	"bytes"
-	"fmt"
 	"math"
 	"sync"
 	"sync/atomic"
@@ -81,36 +80,32 @@ func (t *batchTx) unsafePut(bucketName []byte, key []byte, value []byte, seq boo
 
 // UnsafeRange must be called holding the lock on the tx.
 func (t *batchTx) UnsafeRange(bucketName, key, endKey []byte, limit int64) ([][]byte, [][]byte) {
-	k, v, err := unsafeRange(t.tx, bucketName, key, endKey, limit)
-	if err != nil {
-		plog.Fatal(err)
+	bucket := t.tx.Bucket(bucketName)
+	if bucket == nil {
+		plog.Fatalf("bucket %s does not exist", bucketName)
 	}
-	return k, v
+	return unsafeRange(bucket.Cursor(), key, endKey, limit)
 }
 
-func unsafeRange(tx *bolt.Tx, bucketName, key, endKey []byte, limit int64) (keys [][]byte, vs [][]byte, err error) {
-	bucket := tx.Bucket(bucketName)
-	if bucket == nil {
-		return nil, nil, fmt.Errorf("bucket %s does not exist", bucketName)
-	}
-	if len(endKey) == 0 {
-		if v := bucket.Get(key); v != nil {
-			return append(keys, key), append(vs, v), nil
-		}
-		return nil, nil, nil
-	}
+func unsafeRange(c *bolt.Cursor, key, endKey []byte, limit int64) (keys [][]byte, vs [][]byte) {
 	if limit <= 0 {
 		limit = math.MaxInt64
 	}
-	c := bucket.Cursor()
-	for ck, cv := c.Seek(key); ck != nil && bytes.Compare(ck, endKey) < 0; ck, cv = c.Next() {
+	var isMatch func(b []byte) bool
+	if len(endKey) > 0 {
+		isMatch = func(b []byte) bool { return bytes.Compare(b, endKey) < 0 }
+	} else {
+		isMatch = func(b []byte) bool { return bytes.Equal(b, key) }
+		limit = 1
+	}
+	for ck, cv := c.Seek(key); ck != nil && isMatch(ck); ck, cv = c.Next() {
 		vs = append(vs, cv)
 		keys = append(keys, ck)
 		if limit == int64(len(keys)) {
 			break
 		}
 	}
-	return keys, vs, nil
+	return keys, vs
 }
 
 // UnsafeDelete must be called holding the lock on the tx.
@@ -238,8 +233,7 @@ func (t *batchTxBuffered) unsafeCommit(stop bool) {
 		if err := t.backend.readTx.tx.Rollback(); err != nil {
 			plog.Fatalf("cannot rollback tx (%s)", err)
 		}
-		t.backend.readTx.buf.reset()
-		t.backend.readTx.tx = nil
+		t.backend.readTx.reset()
 	}
 
 	t.batchTx.commit(stop)
diff --git a/vendor/github.com/coreos/etcd/mvcc/backend/config_linux.go b/vendor/github.com/coreos/etcd/mvcc/backend/config_linux.go
index a8f6abeba63..b01785f3b33 100644
--- a/vendor/github.com/coreos/etcd/mvcc/backend/config_linux.go
+++ b/vendor/github.com/coreos/etcd/mvcc/backend/config_linux.go
@@ -27,7 +27,8 @@ import (
 // (https://github.com/torvalds/linux/releases/tag/v2.6.23), mmap might
 // silently ignore this flag. Please update your kernel to prevent this.
 var boltOpenOptions = &bolt.Options{
-	MmapFlags: syscall.MAP_POPULATE,
+	MmapFlags:      syscall.MAP_POPULATE,
+	NoFreelistSync: true,
 }
 
 func (bcfg *BackendConfig) mmapSize() int { return int(bcfg.MmapSize) }
diff --git a/vendor/github.com/coreos/etcd/mvcc/backend/read_tx.go b/vendor/github.com/coreos/etcd/mvcc/backend/read_tx.go
index 9fc6b790620..0536de70e2b 100644
--- a/vendor/github.com/coreos/etcd/mvcc/backend/read_tx.go
+++ b/vendor/github.com/coreos/etcd/mvcc/backend/read_tx.go
@@ -40,9 +40,10 @@ type readTx struct {
 	mu  sync.RWMutex
 	buf txReadBuffer
 
-	// txmu protects accesses to the Tx on Range requests
-	txmu sync.Mutex
-	tx   *bolt.Tx
+	// txmu protects accesses to buckets and tx on Range requests.
+	txmu    sync.RWMutex
+	tx      *bolt.Tx
+	buckets map[string]*bolt.Bucket
 }
 
 func (rt *readTx) Lock()   { rt.mu.RLock() }
@@ -63,30 +64,57 @@ func (rt *readTx) UnsafeRange(bucketName, key, endKey []byte, limit int64) ([][]
 	if int64(len(keys)) == limit {
 		return keys, vals
 	}
+
+	// find/cache bucket
+	bn := string(bucketName)
+	rt.txmu.RLock()
+	bucket, ok := rt.buckets[bn]
+	rt.txmu.RUnlock()
+	if !ok {
+		rt.txmu.Lock()
+		bucket = rt.tx.Bucket(bucketName)
+		rt.buckets[bn] = bucket
+		rt.txmu.Unlock()
+	}
+
+	// ignore missing bucket since may have been created in this batch
+	if bucket == nil {
+		return keys, vals
+	}
 	rt.txmu.Lock()
-	// ignore error since bucket may have been created in this batch
-	k2, v2, _ := unsafeRange(rt.tx, bucketName, key, endKey, limit-int64(len(keys)))
+	c := bucket.Cursor()
 	rt.txmu.Unlock()
+
+	k2, v2 := unsafeRange(c, key, endKey, limit-int64(len(keys)))
 	return append(k2, keys...), append(v2, vals...)
 }
 
 func (rt *readTx) UnsafeForEach(bucketName []byte, visitor func(k, v []byte) error) error {
 	dups := make(map[string]struct{})
-	f1 := func(k, v []byte) error {
+	getDups := func(k, v []byte) error {
 		dups[string(k)] = struct{}{}
-		return visitor(k, v)
+		return nil
 	}
-	f2 := func(k, v []byte) error {
+	visitNoDup := func(k, v []byte) error {
 		if _, ok := dups[string(k)]; ok {
 			return nil
 		}
 		return visitor(k, v)
 	}
-	if err := rt.buf.ForEach(bucketName, f1); err != nil {
+	if err := rt.buf.ForEach(bucketName, getDups); err != nil {
 		return err
 	}
 	rt.txmu.Lock()
-	err := unsafeForEach(rt.tx, bucketName, f2)
+	err := unsafeForEach(rt.tx, bucketName, visitNoDup)
 	rt.txmu.Unlock()
-	return err
+	if err != nil {
+		return err
+	}
+	return rt.buf.ForEach(bucketName, visitor)
+}
+
+func (rt *readTx) reset() {
+	rt.buf.reset()
+	rt.buckets = make(map[string]*bolt.Bucket)
+	rt.tx = nil
 }
diff --git a/vendor/github.com/coreos/etcd/mvcc/index.go b/vendor/github.com/coreos/etcd/mvcc/index.go
index 991289cdd5c..b27a9e54339 100644
--- a/vendor/github.com/coreos/etcd/mvcc/index.go
+++ b/vendor/github.com/coreos/etcd/mvcc/index.go
@@ -24,10 +24,12 @@ import (
 type index interface {
 	Get(key []byte, atRev int64) (rev, created revision, ver int64, err error)
 	Range(key, end []byte, atRev int64) ([][]byte, []revision)
+	Revisions(key, end []byte, atRev int64) []revision
 	Put(key []byte, rev revision)
 	Tombstone(key []byte, rev revision) error
 	RangeSince(key, end []byte, rev int64) []revision
 	Compact(rev int64) map[revision]struct{}
+	Keep(rev int64) map[revision]struct{}
 	Equal(b index) bool
 
 	Insert(ki *keyIndex)
@@ -83,17 +85,8 @@ func (ti *treeIndex) keyIndex(keyi *keyIndex) *keyIndex {
 	return nil
 }
 
-func (ti *treeIndex) Range(key, end []byte, atRev int64) (keys [][]byte, revs []revision) {
-	if end == nil {
-		rev, _, _, err := ti.Get(key, atRev)
-		if err != nil {
-			return nil, nil
-		}
-		return [][]byte{key}, []revision{rev}
-	}
-
-	keyi := &keyIndex{key: key}
-	endi := &keyIndex{key: end}
+func (ti *treeIndex) visit(key, end []byte, f func(ki *keyIndex)) {
+	keyi, endi := &keyIndex{key: key}, &keyIndex{key: end}
 
 	ti.RLock()
 	defer ti.RUnlock()
@@ -102,16 +95,41 @@ func (ti *treeIndex) Range(key, end []byte, atRev int64) (keys [][]byte, revs []
 		if len(endi.key) > 0 && !item.Less(endi) {
 			return false
 		}
-		curKeyi := item.(*keyIndex)
-		rev, _, _, err := curKeyi.get(atRev)
-		if err != nil {
-			return true
-		}
-		revs = append(revs, rev)
-		keys = append(keys, curKeyi.key)
+		f(item.(*keyIndex))
 		return true
 	})
+}
 
+func (ti *treeIndex) Revisions(key, end []byte, atRev int64) (revs []revision) {
+	if end == nil {
+		rev, _, _, err := ti.Get(key, atRev)
+		if err != nil {
+			return nil
+		}
+		return []revision{rev}
+	}
+	ti.visit(key, end, func(ki *keyIndex) {
+		if rev, _, _, err := ki.get(atRev); err == nil {
+			revs = append(revs, rev)
+		}
+	})
+	return revs
+}
+
+func (ti *treeIndex) Range(key, end []byte, atRev int64) (keys [][]byte, revs []revision) {
+	if end == nil {
+		rev, _, _, err := ti.Get(key, atRev)
+		if err != nil {
+			return nil, nil
+		}
+		return [][]byte{key}, []revision{rev}
+	}
+	ti.visit(key, end, func(ki *keyIndex) {
+		if rev, _, _, err := ki.get(atRev); err == nil {
+			revs = append(revs, rev)
+			keys = append(keys, ki.key)
+		}
+	})
 	return keys, revs
 }
 
@@ -133,10 +151,11 @@ func (ti *treeIndex) Tombstone(key []byte, rev revision) error {
 // at or after the given rev. The returned slice is sorted in the order
 // of revision.
 func (ti *treeIndex) RangeSince(key, end []byte, rev int64) []revision {
+	keyi := &keyIndex{key: key}
+
 	ti.RLock()
 	defer ti.RUnlock()
 
-	keyi := &keyIndex{key: key}
 	if end == nil {
 		item := ti.tree.Get(keyi)
 		if item == nil {
@@ -179,6 +198,19 @@ func (ti *treeIndex) Compact(rev int64) map[revision]struct{} {
 	return available
 }
 
+// Keep finds all revisions to be kept for a Compaction at the given rev.
+func (ti *treeIndex) Keep(rev int64) map[revision]struct{} {
+	available := make(map[revision]struct{})
+	ti.RLock()
+	defer ti.RUnlock()
+	ti.tree.Ascend(func(i btree.Item) bool {
+		keyi := i.(*keyIndex)
+		keyi.keep(rev, available)
+		return true
+	})
+	return available
+}
+
 func compactIndex(rev int64, available map[revision]struct{}, emptyki *[]*keyIndex) func(i btree.Item) bool {
 	return func(i btree.Item) bool {
 		keyi := i.(*keyIndex)
@@ -190,16 +222,16 @@ func compactIndex(rev int64, available map[revision]struct{}, emptyki *[]*keyInd
 	}
 }
 
-func (a *treeIndex) Equal(bi index) bool {
+func (ti *treeIndex) Equal(bi index) bool {
 	b := bi.(*treeIndex)
 
-	if a.tree.Len() != b.tree.Len() {
+	if ti.tree.Len() != b.tree.Len() {
 		return false
 	}
 
 	equal := true
 
-	a.tree.Ascend(func(item btree.Item) bool {
+	ti.tree.Ascend(func(item btree.Item) bool {
 		aki := item.(*keyIndex)
 		bki := b.tree.Get(item).(*keyIndex)
 		if !aki.equal(bki) {
diff --git a/vendor/github.com/coreos/etcd/mvcc/key_index.go b/vendor/github.com/coreos/etcd/mvcc/key_index.go
index 9104f9b2d36..805922bfc9a 100644
--- a/vendor/github.com/coreos/etcd/mvcc/key_index.go
+++ b/vendor/github.com/coreos/etcd/mvcc/key_index.go
@@ -46,7 +46,7 @@ var (
 // rev except the largest one. If the generation becomes empty
 // during compaction, it will be removed. if all the generations get
 // removed, the keyIndex should be removed.
-
+//
 // For example:
 // compact(2) on the previous example
 // generations:
@@ -187,9 +187,44 @@ func (ki *keyIndex) compact(atRev int64, available map[revision]struct{}) {
 		plog.Panicf("store.keyindex: unexpected compact on empty keyIndex %s", string(ki.key))
 	}
 
-	// walk until reaching the first revision that has an revision smaller or equal to
-	// the atRev.
-	// add it to the available map
+	genIdx, revIndex := ki.doCompact(atRev, available)
+
+	g := &ki.generations[genIdx]
+	if !g.isEmpty() {
+		// remove the previous contents.
+		if revIndex != -1 {
+			g.revs = g.revs[revIndex:]
+		}
+		// remove any tombstone
+		if len(g.revs) == 1 && genIdx != len(ki.generations)-1 {
+			delete(available, g.revs[0])
+			genIdx++
+		}
+	}
+
+	// remove the previous generations.
+	ki.generations = ki.generations[genIdx:]
+}
+
+// keep finds the revision to be kept if compact is called at given atRev.
+func (ki *keyIndex) keep(atRev int64, available map[revision]struct{}) {
+	if ki.isEmpty() {
+		return
+	}
+
+	genIdx, revIndex := ki.doCompact(atRev, available)
+	g := &ki.generations[genIdx]
+	if !g.isEmpty() {
+		// remove any tombstone
+		if revIndex == len(g.revs)-1 && genIdx != len(ki.generations)-1 {
+			delete(available, g.revs[revIndex])
+		}
+	}
+}
+
+func (ki *keyIndex) doCompact(atRev int64, available map[revision]struct{}) (genIdx int, revIndex int) {
+	// walk until reaching the first revision smaller or equal to "atRev",
+	// and add the revision to the available map
 	f := func(rev revision) bool {
 		if rev.main <= atRev {
 			available[rev] = struct{}{}
@@ -198,30 +233,19 @@ func (ki *keyIndex) compact(atRev int64, available map[revision]struct{}) {
 		return true
 	}
 
-	i, g := 0, &ki.generations[0]
+	genIdx, g := 0, &ki.generations[0]
 	// find first generation includes atRev or created after atRev
-	for i < len(ki.generations)-1 {
+	for genIdx < len(ki.generations)-1 {
 		if tomb := g.revs[len(g.revs)-1].main; tomb > atRev {
 			break
 		}
-		i++
-		g = &ki.generations[i]
+		genIdx++
+		g = &ki.generations[genIdx]
 	}
 
-	if !g.isEmpty() {
-		n := g.walk(f)
-		// remove the previous contents.
-		if n != -1 {
-			g.revs = g.revs[n:]
-		}
-		// remove any tombstone
-		if len(g.revs) == 1 && i != len(ki.generations)-1 {
-			delete(available, g.revs[0])
-			i++
-		}
-	}
-	// remove the previous generations.
-	ki.generations = ki.generations[i:]
+	revIndex = g.walk(f)
+
+	return genIdx, revIndex
 }
 
 func (ki *keyIndex) isEmpty() bool {
diff --git a/vendor/github.com/coreos/etcd/mvcc/kv.go b/vendor/github.com/coreos/etcd/mvcc/kv.go
index 6636347aa43..2dad3ad8ef0 100644
--- a/vendor/github.com/coreos/etcd/mvcc/kv.go
+++ b/vendor/github.com/coreos/etcd/mvcc/kv.go
@@ -107,10 +107,12 @@ type KV interface {
 	// Write creates a write transaction.
 	Write() TxnWrite
 
-	// Hash retrieves the hash of KV state and revision.
-	// This method is designed for consistency checking purposes.
+	// Hash computes the hash of the KV's backend.
 	Hash() (hash uint32, revision int64, err error)
 
+	// HashByRev computes the hash of all MVCC revisions up to a given revision.
+	HashByRev(rev int64) (hash uint32, revision int64, compactRev int64, err error)
+
 	// Compact frees all superseded keys with revisions less than rev.
 	Compact(rev int64) (<-chan struct{}, error)
 
diff --git a/vendor/github.com/coreos/etcd/mvcc/kvstore.go b/vendor/github.com/coreos/etcd/mvcc/kvstore.go
index c68256685f8..dd9f04ae211 100644
--- a/vendor/github.com/coreos/etcd/mvcc/kvstore.go
+++ b/vendor/github.com/coreos/etcd/mvcc/kvstore.go
@@ -15,10 +15,13 @@
 package mvcc
 
 import (
+	"context"
 	"encoding/binary"
 	"errors"
+	"hash/crc32"
 	"math"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/coreos/etcd/lease"
@@ -26,7 +29,6 @@ import (
 	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/schedule"
 	"github.com/coreos/pkg/capnslog"
-	"golang.org/x/net/context"
 )
 
 var (
@@ -67,6 +69,10 @@ type store struct {
 	ReadView
 	WriteView
 
+	// consistentIndex caches the "consistent_index" key's value. Accessed
+	// through atomics so must be 64-bit aligned.
+	consistentIndex uint64
+
 	// mu read locks for txns and write locks for non-txn store changes.
 	mu sync.RWMutex
 
@@ -159,6 +165,59 @@ func (s *store) Hash() (hash uint32, revision int64, err error) {
 	return h, s.currentRev, err
 }
 
+func (s *store) HashByRev(rev int64) (hash uint32, currentRev int64, compactRev int64, err error) {
+	start := time.Now()
+
+	s.mu.RLock()
+	s.revMu.RLock()
+	compactRev, currentRev = s.compactMainRev, s.currentRev
+	s.revMu.RUnlock()
+
+	if rev > 0 && rev <= compactRev {
+		s.mu.RUnlock()
+		return 0, 0, compactRev, ErrCompacted
+	} else if rev > 0 && rev > currentRev {
+		s.mu.RUnlock()
+		return 0, currentRev, 0, ErrFutureRev
+	}
+
+	if rev == 0 {
+		rev = currentRev
+	}
+	keep := s.kvindex.Keep(rev)
+
+	tx := s.b.ReadTx()
+	tx.Lock()
+	defer tx.Unlock()
+	s.mu.RUnlock()
+
+	upper := revision{main: rev + 1}
+	lower := revision{main: compactRev + 1}
+	h := crc32.New(crc32.MakeTable(crc32.Castagnoli))
+
+	h.Write(keyBucketName)
+	err = tx.UnsafeForEach(keyBucketName, func(k, v []byte) error {
+		kr := bytesToRev(k)
+		if !upper.GreaterThan(kr) {
+			return nil
+		}
+		// skip revisions that are scheduled for deletion
+		// due to compacting; don't skip if there isn't one.
+		if lower.GreaterThan(kr) && len(keep) > 0 {
+			if _, ok := keep[kr]; !ok {
+				return nil
+			}
+		}
+		h.Write(k)
+		h.Write(v)
+		return nil
+	})
+	hash = h.Sum32()
+
+	hashRevDurations.Observe(time.Since(start).Seconds())
+	return hash, currentRev, compactRev, err
+}
+
 func (s *store) Compact(rev int64) (<-chan struct{}, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -238,6 +297,7 @@ func (s *store) Restore(b backend.Backend) error {
 	close(s.stopc)
 	s.fifoSched.Stop()
 
+	atomic.StoreUint64(&s.consistentIndex, 0)
 	s.b = b
 	s.kvindex = newTreeIndex()
 	s.currentRev = 1
@@ -407,29 +467,23 @@ func (s *store) Close() error {
 	return nil
 }
 
-func (a *store) Equal(b *store) bool {
-	if a.currentRev != b.currentRev {
-		return false
-	}
-	if a.compactMainRev != b.compactMainRev {
-		return false
-	}
-	return a.kvindex.Equal(b.kvindex)
-}
-
 func (s *store) saveIndex(tx backend.BatchTx) {
 	if s.ig == nil {
 		return
 	}
 	bs := s.bytesBuf8
-	binary.BigEndian.PutUint64(bs, s.ig.ConsistentIndex())
+	ci := s.ig.ConsistentIndex()
+	binary.BigEndian.PutUint64(bs, ci)
 	// put the index into the underlying backend
 	// tx has been locked in TxnBegin, so there is no need to lock it again
 	tx.UnsafePut(metaBucketName, consistentIndexKeyName, bs)
+	atomic.StoreUint64(&s.consistentIndex, ci)
 }
 
 func (s *store) ConsistentIndex() uint64 {
-	// TODO: cache index in a uint64 field?
+	if ci := atomic.LoadUint64(&s.consistentIndex); ci > 0 {
+		return ci
+	}
 	tx := s.b.BatchTx()
 	tx.Lock()
 	defer tx.Unlock()
@@ -437,7 +491,9 @@ func (s *store) ConsistentIndex() uint64 {
 	if len(vs) == 0 {
 		return 0
 	}
-	return binary.BigEndian.Uint64(vs[0])
+	v := binary.BigEndian.Uint64(vs[0])
+	atomic.StoreUint64(&s.consistentIndex, v)
+	return v
 }
 
 // appendMarkTombstone appends tombstone mark to normal revision bytes.
@@ -452,16 +508,3 @@ func appendMarkTombstone(b []byte) []byte {
 func isTombstone(b []byte) bool {
 	return len(b) == markedRevBytesLen && b[markBytePosition] == markTombstone
 }
-
-// revBytesRange returns the range of revision bytes at
-// the given revision.
-func revBytesRange(rev revision) (start, end []byte) {
-	start = newRevBytes()
-	revToBytes(rev, start)
-
-	end = newRevBytes()
-	endRev := revision{main: rev.main, sub: rev.sub + 1}
-	revToBytes(endRev, end)
-
-	return start, end
-}
diff --git a/vendor/github.com/coreos/etcd/mvcc/kvstore_compaction.go b/vendor/github.com/coreos/etcd/mvcc/kvstore_compaction.go
index bbd38f547f3..1726490c110 100644
--- a/vendor/github.com/coreos/etcd/mvcc/kvstore_compaction.go
+++ b/vendor/github.com/coreos/etcd/mvcc/kvstore_compaction.go
@@ -22,6 +22,8 @@ import (
 func (s *store) scheduleCompaction(compactMainRev int64, keep map[revision]struct{}) bool {
 	totalStart := time.Now()
 	defer dbCompactionTotalDurations.Observe(float64(time.Since(totalStart) / time.Millisecond))
+	keyCompactions := 0
+	defer func() { dbCompactionKeysCounter.Add(float64(keyCompactions)) }()
 
 	end := make([]byte, 8)
 	binary.BigEndian.PutUint64(end, uint64(compactMainRev+1))
@@ -40,6 +42,7 @@ func (s *store) scheduleCompaction(compactMainRev int64, keep map[revision]struc
 			rev = bytesToRev(key)
 			if _, ok := keep[rev]; !ok {
 				tx.UnsafeDelete(keyBucketName, key)
+				keyCompactions++
 			}
 		}
 
diff --git a/vendor/github.com/coreos/etcd/mvcc/kvstore_txn.go b/vendor/github.com/coreos/etcd/mvcc/kvstore_txn.go
index 13d4d530d0a..8896fb86dbf 100644
--- a/vendor/github.com/coreos/etcd/mvcc/kvstore_txn.go
+++ b/vendor/github.com/coreos/etcd/mvcc/kvstore_txn.go
@@ -51,7 +51,7 @@ func (tr *storeTxnRead) End() {
 }
 
 type storeTxnWrite struct {
-	*storeTxnRead
+	storeTxnRead
 	tx backend.BatchTx
 	// beginRev is the revision where the txn begins; it will write to the next revision.
 	beginRev int64
@@ -63,7 +63,7 @@ func (s *store) Write() TxnWrite {
 	tx := s.b.BatchTx()
 	tx.Lock()
 	tw := &storeTxnWrite{
-		storeTxnRead: &storeTxnRead{s, tx, 0, 0},
+		storeTxnRead: storeTxnRead{s, tx, 0, 0},
 		tx:           tx,
 		beginRev:     s.currentRev,
 		changes:      make([]mvccpb.KeyValue, 0, 4),
@@ -120,7 +120,7 @@ func (tr *storeTxnRead) rangeKeys(key, end []byte, curRev int64, ro RangeOptions
 		return &RangeResult{KVs: nil, Count: -1, Rev: 0}, ErrCompacted
 	}
 
-	_, revpairs := tr.s.kvindex.Range(key, end, int64(rev))
+	revpairs := tr.s.kvindex.Revisions(key, end, int64(rev))
 	if len(revpairs) == 0 {
 		return &RangeResult{KVs: nil, Count: 0, Rev: curRev}, nil
 	}
@@ -128,22 +128,22 @@ func (tr *storeTxnRead) rangeKeys(key, end []byte, curRev int64, ro RangeOptions
 		return &RangeResult{KVs: nil, Count: len(revpairs), Rev: curRev}, nil
 	}
 
-	var kvs []mvccpb.KeyValue
-	for _, revpair := range revpairs {
-		start, end := revBytesRange(revpair)
-		_, vs := tr.tx.UnsafeRange(keyBucketName, start, end, 0)
+	limit := int(ro.Limit)
+	if limit <= 0 || limit > len(revpairs) {
+		limit = len(revpairs)
+	}
+
+	kvs := make([]mvccpb.KeyValue, limit)
+	revBytes := newRevBytes()
+	for i, revpair := range revpairs[:len(kvs)] {
+		revToBytes(revpair, revBytes)
+		_, vs := tr.tx.UnsafeRange(keyBucketName, revBytes, nil, 0)
 		if len(vs) != 1 {
 			plog.Fatalf("range cannot find rev (%d,%d)", revpair.main, revpair.sub)
 		}
-
-		var kv mvccpb.KeyValue
-		if err := kv.Unmarshal(vs[0]); err != nil {
+		if err := kvs[i].Unmarshal(vs[0]); err != nil {
 			plog.Fatalf("cannot unmarshal event: %v", err)
 		}
-		kvs = append(kvs, kv)
-		if ro.Limit > 0 && len(kvs) >= int(ro.Limit) {
-			break
-		}
 	}
 	return &RangeResult{KVs: kvs, Count: len(revpairs), Rev: curRev}, nil
 }
diff --git a/vendor/github.com/coreos/etcd/mvcc/metrics.go b/vendor/github.com/coreos/etcd/mvcc/metrics.go
index 90bf9ecae46..b753310cff0 100644
--- a/vendor/github.com/coreos/etcd/mvcc/metrics.go
+++ b/vendor/github.com/coreos/etcd/mvcc/metrics.go
@@ -131,6 +131,14 @@ var (
 			Buckets: prometheus.ExponentialBuckets(100, 2, 14),
 		})
 
+	dbCompactionKeysCounter = prometheus.NewCounter(
+		prometheus.CounterOpts{
+			Namespace: "etcd_debugging",
+			Subsystem: "mvcc",
+			Name:      "db_compaction_keys_total",
+			Help:      "Total number of db keys compacted.",
+		})
+
 	dbTotalSizeDebugging = prometheus.NewGaugeFunc(prometheus.GaugeOpts{
 		Namespace: "etcd_debugging",
 		Subsystem: "mvcc",
@@ -186,6 +194,18 @@ var (
 		// highest bucket start of 0.01 sec * 2^14 == 163.84 sec
 		Buckets: prometheus.ExponentialBuckets(.01, 2, 15),
 	})
+
+	hashRevDurations = prometheus.NewHistogram(prometheus.HistogramOpts{
+		Namespace: "etcd",
+		Subsystem: "mvcc",
+		Name:      "hash_rev_duration_seconds",
+		Help:      "The latency distribution of storage hash by revision operation.",
+
+		// 100 MB usually takes 100 ms, so start with 10 MB of 10 ms
+		// lowest bucket start of upper bound 0.01 sec (10 ms) with factor 2
+		// highest bucket start of 0.01 sec * 2^14 == 163.84 sec
+		Buckets: prometheus.ExponentialBuckets(.01, 2, 15),
+	})
 )
 
 func init() {
@@ -202,10 +222,12 @@ func init() {
 	prometheus.MustRegister(indexCompactionPauseDurations)
 	prometheus.MustRegister(dbCompactionPauseDurations)
 	prometheus.MustRegister(dbCompactionTotalDurations)
+	prometheus.MustRegister(dbCompactionKeysCounter)
 	prometheus.MustRegister(dbTotalSizeDebugging)
 	prometheus.MustRegister(dbTotalSize)
 	prometheus.MustRegister(dbTotalSizeInUse)
 	prometheus.MustRegister(hashDurations)
+	prometheus.MustRegister(hashRevDurations)
 }
 
 // ReportEventReceived reports that an event is received.
diff --git a/vendor/github.com/coreos/etcd/mvcc/metrics_txn.go b/vendor/github.com/coreos/etcd/mvcc/metrics_txn.go
index fd2144279ae..911d64875d7 100644
--- a/vendor/github.com/coreos/etcd/mvcc/metrics_txn.go
+++ b/vendor/github.com/coreos/etcd/mvcc/metrics_txn.go
@@ -50,18 +50,10 @@ func (tw *metricsTxnWrite) Put(key, value []byte, lease lease.LeaseID) (rev int6
 
 func (tw *metricsTxnWrite) End() {
 	defer tw.TxnWrite.End()
-	if sum := tw.ranges + tw.puts + tw.deletes; sum != 1 {
-		if sum > 1 {
-			txnCounter.Inc()
-		}
-		return
-	}
-	switch {
-	case tw.ranges == 1:
-		rangeCounter.Inc()
-	case tw.puts == 1:
-		putCounter.Inc()
-	case tw.deletes == 1:
-		deleteCounter.Inc()
+	if sum := tw.ranges + tw.puts + tw.deletes; sum > 1 {
+		txnCounter.Inc()
 	}
+	rangeCounter.Add(float64(tw.ranges))
+	putCounter.Add(float64(tw.puts))
+	deleteCounter.Add(float64(tw.deletes))
 }
diff --git a/vendor/github.com/coreos/etcd/mvcc/mvccpb/BUILD b/vendor/github.com/coreos/etcd/mvcc/mvccpb/BUILD
index bf4a3819162..cf28eff008b 100644
--- a/vendor/github.com/coreos/etcd/mvcc/mvccpb/BUILD
+++ b/vendor/github.com/coreos/etcd/mvcc/mvccpb/BUILD
@@ -6,7 +6,10 @@ go_library(
     importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/mvcc/mvccpb",
     importpath = "github.com/coreos/etcd/mvcc/mvccpb",
     visibility = ["//visibility:public"],
-    deps = ["//vendor/github.com/golang/protobuf/proto:go_default_library"],
+    deps = [
+        "//vendor/github.com/gogo/protobuf/gogoproto:go_default_library",
+        "//vendor/github.com/golang/protobuf/proto:go_default_library",
+    ],
 )
 
 filegroup(
diff --git a/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.pb.go b/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.pb.go
index 7033f132662..23fe337a59b 100644
--- a/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.pb.go
+++ b/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: kv.proto
-// DO NOT EDIT!
 
 /*
 	Package mvccpb is a generated protocol buffer package.
@@ -21,6 +20,8 @@ import (
 
 	math "math"
 
+	_ "github.com/gogo/protobuf/gogoproto"
+
 	io "io"
 )
 
@@ -198,24 +199,6 @@ func (m *Event) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Kv(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Kv(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintKv(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/coreos/etcd/mvcc/watchable_store.go b/vendor/github.com/coreos/etcd/mvcc/watchable_store.go
index cb9d1705b76..78df19326b9 100644
--- a/vendor/github.com/coreos/etcd/mvcc/watchable_store.go
+++ b/vendor/github.com/coreos/etcd/mvcc/watchable_store.go
@@ -23,7 +23,8 @@ import (
 	"github.com/coreos/etcd/mvcc/mvccpb"
 )
 
-const (
+// non-const so modifiable by tests
+var (
 	// chanBufLen is the length of the buffered chan
 	// for sending out watched events.
 	// TODO: find a good buf value. 1024 is just a random one that
@@ -143,7 +144,6 @@ func (s *watchableStore) watch(key, end []byte, startRev int64, id WatchID, ch c
 func (s *watchableStore) cancelWatcher(wa *watcher) {
 	for {
 		s.mu.Lock()
-
 		if s.unsynced.delete(wa) {
 			slowWatcherGauge.Dec()
 			break
@@ -151,6 +151,9 @@ func (s *watchableStore) cancelWatcher(wa *watcher) {
 			break
 		} else if wa.compacted {
 			break
+		} else if wa.ch == nil {
+			// already canceled (e.g., cancel/close race)
+			break
 		}
 
 		if !wa.victim {
@@ -176,6 +179,7 @@ func (s *watchableStore) cancelWatcher(wa *watcher) {
 	}
 
 	watcherGauge.Dec()
+	wa.ch = nil
 	s.mu.Unlock()
 }
 
@@ -425,7 +429,6 @@ func (s *watchableStore) notify(rev int64, evs []mvccpb.Event) {
 		if eb.revs != 1 {
 			plog.Panicf("unexpected multiple revisions in notification")
 		}
-
 		if w.send(WatchResponse{WatchID: w.id, Events: eb.evs, Revision: rev}) {
 			pendingEventsGauge.Add(float64(len(eb.evs)))
 		} else {
diff --git a/vendor/github.com/coreos/etcd/mvcc/watcher.go b/vendor/github.com/coreos/etcd/mvcc/watcher.go
index 9468d42695c..bc0c6322fd1 100644
--- a/vendor/github.com/coreos/etcd/mvcc/watcher.go
+++ b/vendor/github.com/coreos/etcd/mvcc/watcher.go
@@ -129,16 +129,25 @@ func (ws *watchStream) Chan() <-chan WatchResponse {
 func (ws *watchStream) Cancel(id WatchID) error {
 	ws.mu.Lock()
 	cancel, ok := ws.cancels[id]
+	w := ws.watchers[id]
 	ok = ok && !ws.closed
-	if ok {
-		delete(ws.cancels, id)
-		delete(ws.watchers, id)
-	}
 	ws.mu.Unlock()
+
 	if !ok {
 		return ErrWatcherNotExist
 	}
 	cancel()
+
+	ws.mu.Lock()
+	// The watch isn't removed until cancel so that if Close() is called,
+	// it will wait for the cancel. Otherwise, Close() could close the
+	// watch channel while the store is still posting events.
+	if ww := ws.watchers[id]; ww == w {
+		delete(ws.cancels, id)
+		delete(ws.watchers, id)
+	}
+	ws.mu.Unlock()
+
 	return nil
 }
 
diff --git a/vendor/github.com/coreos/etcd/pkg/adt/interval_tree.go b/vendor/github.com/coreos/etcd/pkg/adt/interval_tree.go
index 9769771ea4f..ec302e4a7a9 100644
--- a/vendor/github.com/coreos/etcd/pkg/adt/interval_tree.go
+++ b/vendor/github.com/coreos/etcd/pkg/adt/interval_tree.go
@@ -485,6 +485,15 @@ func (ivt *IntervalTree) Stab(iv Interval) (ivs []*IntervalValue) {
 	return ivs
 }
 
+// Union merges a given interval tree into the receiver.
+func (ivt *IntervalTree) Union(inIvt IntervalTree, ivl Interval) {
+	f := func(n *IntervalValue) bool {
+		ivt.Insert(n.Ivl, n.Val)
+		return true
+	}
+	inIvt.Visit(ivl, f)
+}
+
 type StringComparable string
 
 func (s StringComparable) Compare(c Comparable) int {
diff --git a/vendor/github.com/coreos/etcd/pkg/fileutil/lock_windows.go b/vendor/github.com/coreos/etcd/pkg/fileutil/lock_windows.go
index 8698f4a8d11..b1817230a3c 100644
--- a/vendor/github.com/coreos/etcd/pkg/fileutil/lock_windows.go
+++ b/vendor/github.com/coreos/etcd/pkg/fileutil/lock_windows.go
@@ -121,5 +121,5 @@ func lockFileEx(h syscall.Handle, flags, locklow, lockhigh uint32, ol *syscall.O
 			err = syscall.EINVAL
 		}
 	}
-	return
+	return err
 }
diff --git a/vendor/github.com/coreos/etcd/pkg/fileutil/preallocate_darwin.go b/vendor/github.com/coreos/etcd/pkg/fileutil/preallocate_darwin.go
index 1ed09c560f2..5a6dccfa796 100644
--- a/vendor/github.com/coreos/etcd/pkg/fileutil/preallocate_darwin.go
+++ b/vendor/github.com/coreos/etcd/pkg/fileutil/preallocate_darwin.go
@@ -30,6 +30,8 @@ func preallocExtend(f *os.File, sizeInBytes int64) error {
 }
 
 func preallocFixed(f *os.File, sizeInBytes int64) error {
+	// allocate all requested space or no space at all
+	// TODO: allocate contiguous space on disk with F_ALLOCATECONTIG flag
 	fstore := &syscall.Fstore_t{
 		Flags:   syscall.F_ALLOCATEALL,
 		Posmode: syscall.F_PEOFPOSMODE,
@@ -39,5 +41,25 @@ func preallocFixed(f *os.File, sizeInBytes int64) error {
 	if errno == 0 || errno == syscall.ENOTSUP {
 		return nil
 	}
+
+	// wrong argument to fallocate syscall
+	if errno == syscall.EINVAL {
+		// filesystem "st_blocks" are allocated in the units of
+		// "Allocation Block Size" (run "diskutil info /" command)
+		var stat syscall.Stat_t
+		syscall.Fstat(int(f.Fd()), &stat)
+
+		// syscall.Statfs_t.Bsize is "optimal transfer block size"
+		// and contains matching 4096 value when latest OS X kernel
+		// supports 4,096 KB filesystem block size
+		var statfs syscall.Statfs_t
+		syscall.Fstatfs(int(f.Fd()), &statfs)
+		blockSize := int64(statfs.Bsize)
+
+		if stat.Blocks*blockSize >= sizeInBytes {
+			// enough blocks are already allocated
+			return nil
+		}
+	}
 	return errno
 }
diff --git a/vendor/github.com/coreos/etcd/pkg/monotime/BUILD b/vendor/github.com/coreos/etcd/pkg/monotime/BUILD
deleted file mode 100644
index 537f28a32e9..00000000000
--- a/vendor/github.com/coreos/etcd/pkg/monotime/BUILD
+++ /dev/null
@@ -1,27 +0,0 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "issue15006.s",
-        "monotime.go",
-        "nanotime.go",
-    ],
-    importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/pkg/monotime",
-    importpath = "github.com/coreos/etcd/pkg/monotime",
-    visibility = ["//visibility:public"],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)
diff --git a/vendor/github.com/coreos/etcd/pkg/monotime/issue15006.s b/vendor/github.com/coreos/etcd/pkg/monotime/issue15006.s
deleted file mode 100644
index c3132a1f0c8..00000000000
--- a/vendor/github.com/coreos/etcd/pkg/monotime/issue15006.s
+++ /dev/null
@@ -1,6 +0,0 @@
-// Copyright (C) 2016  Arista Networks, Inc.
-// Use of this source code is governed by the Apache License 2.0
-// that can be found in the COPYING file.
-
-// This file is intentionally empty.
-// It's a workaround for https://github.com/golang/go/issues/15006
\ No newline at end of file
diff --git a/vendor/github.com/coreos/etcd/pkg/monotime/nanotime.go b/vendor/github.com/coreos/etcd/pkg/monotime/nanotime.go
deleted file mode 100644
index e3fc846ef9e..00000000000
--- a/vendor/github.com/coreos/etcd/pkg/monotime/nanotime.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright (C) 2016  Arista Networks, Inc.
-// Use of this source code is governed by the Apache License 2.0
-// that can be found in the COPYING file.
-
-// Package monotime provides a fast monotonic clock source.
-package monotime
-
-import (
-	_ "unsafe" // required to use //go:linkname
-)
-
-//go:noescape
-//go:linkname nanotime runtime.nanotime
-func nanotime() int64
-
-// Now returns the current time in nanoseconds from a monotonic clock.
-// The time returned is based on some arbitrary platform-specific point in the
-// past.  The time returned is guaranteed to increase monotonically at a
-// constant rate, unlike time.Now() from the Go standard library, which may
-// slow down, speed up, jump forward or backward, due to NTP activity or leap
-// seconds.
-func Now() Time {
-	return Time(nanotime())
-}
diff --git a/vendor/github.com/coreos/etcd/pkg/netutil/netutil.go b/vendor/github.com/coreos/etcd/pkg/netutil/netutil.go
index 5e38dc98dbf..e3db8c50a0d 100644
--- a/vendor/github.com/coreos/etcd/pkg/netutil/netutil.go
+++ b/vendor/github.com/coreos/etcd/pkg/netutil/netutil.go
@@ -17,6 +17,7 @@ package netutil
 
 import (
 	"context"
+	"fmt"
 	"net"
 	"net/url"
 	"reflect"
@@ -73,14 +74,14 @@ func resolveTCPAddrs(ctx context.Context, urls [][]url.URL) ([][]url.URL, error)
 		for i, u := range us {
 			nu, err := url.Parse(u.String())
 			if err != nil {
-				return nil, err
+				return nil, fmt.Errorf("failed to parse %q (%v)", u.String(), err)
 			}
 			nus[i] = *nu
 		}
 		for i, u := range nus {
 			h, err := resolveURL(ctx, u)
 			if err != nil {
-				return nil, err
+				return nil, fmt.Errorf("failed to resolve %q (%v)", u.String(), err)
 			}
 			if h != "" {
 				nus[i].Host = h
@@ -92,15 +93,19 @@ func resolveTCPAddrs(ctx context.Context, urls [][]url.URL) ([][]url.URL, error)
 }
 
 func resolveURL(ctx context.Context, u url.URL) (string, error) {
+	if u.Scheme == "unix" || u.Scheme == "unixs" {
+		// unix sockets don't resolve over TCP
+		return "", nil
+	}
+	host, _, err := net.SplitHostPort(u.Host)
+	if err != nil {
+		plog.Errorf("could not parse url %s during tcp resolving", u.Host)
+		return "", err
+	}
+	if host == "localhost" || net.ParseIP(host) != nil {
+		return "", nil
+	}
 	for ctx.Err() == nil {
-		host, _, err := net.SplitHostPort(u.Host)
-		if err != nil {
-			plog.Errorf("could not parse url %s during tcp resolving", u.Host)
-			return "", err
-		}
-		if host == "localhost" || net.ParseIP(host) != nil {
-			return "", nil
-		}
 		tcpAddr, err := resolveTCPAddr(ctx, u.Host)
 		if err == nil {
 			plog.Infof("resolving %s to %s", u.Host, tcpAddr.String())
@@ -119,35 +124,41 @@ func resolveURL(ctx context.Context, u url.URL) (string, error) {
 
 // urlsEqual checks equality of url.URLS between two arrays.
 // This check pass even if an URL is in hostname and opposite is in IP address.
-func urlsEqual(ctx context.Context, a []url.URL, b []url.URL) bool {
+func urlsEqual(ctx context.Context, a []url.URL, b []url.URL) (bool, error) {
 	if len(a) != len(b) {
-		return false
+		return false, fmt.Errorf("len(%q) != len(%q)", urlsToStrings(a), urlsToStrings(b))
 	}
 	urls, err := resolveTCPAddrs(ctx, [][]url.URL{a, b})
 	if err != nil {
-		return false
+		return false, err
 	}
+	preva, prevb := a, b
 	a, b = urls[0], urls[1]
 	sort.Sort(types.URLs(a))
 	sort.Sort(types.URLs(b))
 	for i := range a {
 		if !reflect.DeepEqual(a[i], b[i]) {
-			return false
+			return false, fmt.Errorf("%q(resolved from %q) != %q(resolved from %q)",
+				a[i].String(), preva[i].String(),
+				b[i].String(), prevb[i].String(),
+			)
 		}
 	}
-
-	return true
+	return true, nil
 }
 
-func URLStringsEqual(ctx context.Context, a []string, b []string) bool {
+// URLStringsEqual returns "true" if given URLs are valid
+// and resolved to same IP addresses. Otherwise, return "false"
+// and error, if any.
+func URLStringsEqual(ctx context.Context, a []string, b []string) (bool, error) {
 	if len(a) != len(b) {
-		return false
+		return false, fmt.Errorf("len(%q) != len(%q)", a, b)
 	}
 	urlsA := make([]url.URL, 0)
 	for _, str := range a {
 		u, err := url.Parse(str)
 		if err != nil {
-			return false
+			return false, fmt.Errorf("failed to parse %q", str)
 		}
 		urlsA = append(urlsA, *u)
 	}
@@ -155,14 +166,21 @@ func URLStringsEqual(ctx context.Context, a []string, b []string) bool {
 	for _, str := range b {
 		u, err := url.Parse(str)
 		if err != nil {
-			return false
+			return false, fmt.Errorf("failed to parse %q", str)
 		}
 		urlsB = append(urlsB, *u)
 	}
-
 	return urlsEqual(ctx, urlsA, urlsB)
 }
 
+func urlsToStrings(us []url.URL) []string {
+	rs := make([]string, len(us))
+	for i := range us {
+		rs[i] = us[i].String()
+	}
+	return rs
+}
+
 func IsNetworkTimeoutError(err error) bool {
 	nerr, ok := err.(net.Error)
 	return ok && nerr.Timeout()
diff --git a/vendor/github.com/coreos/etcd/pkg/netutil/routes_linux.go b/vendor/github.com/coreos/etcd/pkg/netutil/routes_linux.go
index 5d234d46038..797baeb482a 100644
--- a/vendor/github.com/coreos/etcd/pkg/netutil/routes_linux.go
+++ b/vendor/github.com/coreos/etcd/pkg/netutil/routes_linux.go
@@ -246,5 +246,5 @@ func parsePREFSRC(m *syscall.NetlinkMessage) (host string, oif uint32, err error
 	if oif == 0 {
 		err = errNoDefaultRoute
 	}
-	return
+	return host, oif, err
 }
diff --git a/vendor/github.com/coreos/etcd/pkg/schedule/BUILD b/vendor/github.com/coreos/etcd/pkg/schedule/BUILD
index 68a29e082fd..536a2d5a3fc 100644
--- a/vendor/github.com/coreos/etcd/pkg/schedule/BUILD
+++ b/vendor/github.com/coreos/etcd/pkg/schedule/BUILD
@@ -9,7 +9,6 @@ go_library(
     importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/pkg/schedule",
     importpath = "github.com/coreos/etcd/pkg/schedule",
     visibility = ["//visibility:public"],
-    deps = ["//vendor/golang.org/x/net/context:go_default_library"],
 )
 
 filegroup(
diff --git a/vendor/github.com/coreos/etcd/pkg/schedule/schedule.go b/vendor/github.com/coreos/etcd/pkg/schedule/schedule.go
index bf8528b753a..234d01989df 100644
--- a/vendor/github.com/coreos/etcd/pkg/schedule/schedule.go
+++ b/vendor/github.com/coreos/etcd/pkg/schedule/schedule.go
@@ -15,9 +15,8 @@
 package schedule
 
 import (
+	"context"
 	"sync"
-
-	"golang.org/x/net/context"
 )
 
 type Job func(context.Context)
diff --git a/vendor/github.com/coreos/etcd/pkg/srv/srv.go b/vendor/github.com/coreos/etcd/pkg/srv/srv.go
index fefcbcb4b88..600061ce8ea 100644
--- a/vendor/github.com/coreos/etcd/pkg/srv/srv.go
+++ b/vendor/github.com/coreos/etcd/pkg/srv/srv.go
@@ -71,9 +71,10 @@ func GetCluster(service, name, dns string, apurls types.URLs) ([]string, error)
 			// SRV records have a trailing dot but URL shouldn't.
 			shortHost := strings.TrimSuffix(srv.Target, ".")
 			urlHost := net.JoinHostPort(shortHost, port)
-			stringParts = append(stringParts, fmt.Sprintf("%s=%s://%s", n, scheme, urlHost))
 			if ok && url.Scheme != scheme {
 				err = fmt.Errorf("bootstrap at %s from DNS for %s has scheme mismatch with expected peer %s", scheme+"://"+urlHost, service, url.String())
+			} else {
+				stringParts = append(stringParts, fmt.Sprintf("%s=%s://%s", n, scheme, urlHost))
 			}
 		}
 		if len(stringParts) == 0 {
diff --git a/vendor/github.com/coreos/etcd/pkg/testutil/leak.go b/vendor/github.com/coreos/etcd/pkg/testutil/leak.go
index a29d06d9bd0..2ebae1e6e88 100644
--- a/vendor/github.com/coreos/etcd/pkg/testutil/leak.go
+++ b/vendor/github.com/coreos/etcd/pkg/testutil/leak.go
@@ -119,6 +119,7 @@ func interestingGoroutines() (gs []string) {
 		stack := strings.TrimSpace(sl[1])
 		if stack == "" ||
 			strings.Contains(stack, "sync.(*WaitGroup).Done") ||
+			strings.Contains(stack, "os.(*file).close") ||
 			strings.Contains(stack, "created by os/signal.init") ||
 			strings.Contains(stack, "runtime/panic.go") ||
 			strings.Contains(stack, "created by testing.RunTests") ||
@@ -134,5 +135,5 @@ func interestingGoroutines() (gs []string) {
 		gs = append(gs, stack)
 	}
 	sort.Strings(gs)
-	return
+	return gs
 }
diff --git a/vendor/github.com/coreos/etcd/pkg/testutil/testutil.go b/vendor/github.com/coreos/etcd/pkg/testutil/testutil.go
index db2dd3285b0..0e02ddc0db7 100644
--- a/vendor/github.com/coreos/etcd/pkg/testutil/testutil.go
+++ b/vendor/github.com/coreos/etcd/pkg/testutil/testutil.go
@@ -55,3 +55,30 @@ func FatalStack(t *testing.T, s string) {
 	t.Error(string(stackTrace[:n]))
 	t.Fatalf(s)
 }
+
+// ConditionFunc returns true when a condition is met.
+type ConditionFunc func() (bool, error)
+
+// Poll calls a condition function repeatedly on a polling interval until it returns true, returns an error
+// or the timeout is reached. If the condition function returns true or an error before the timeout, Poll
+// immediately returns with the true value or the error. If the timeout is exceeded, Poll returns false.
+func Poll(interval time.Duration, timeout time.Duration, condition ConditionFunc) (bool, error) {
+	timeoutCh := time.After(timeout)
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-timeoutCh:
+			return false, nil
+		case <-ticker.C:
+			success, err := condition()
+			if err != nil {
+				return false, err
+			}
+			if success {
+				return true, nil
+			}
+		}
+	}
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/keepalive_listener.go b/vendor/github.com/coreos/etcd/pkg/transport/keepalive_listener.go
index 6ccae4ee4a1..4ff8e7f0010 100644
--- a/vendor/github.com/coreos/etcd/pkg/transport/keepalive_listener.go
+++ b/vendor/github.com/coreos/etcd/pkg/transport/keepalive_listener.go
@@ -79,7 +79,7 @@ func (l *tlsKeepaliveListener) Accept() (c net.Conn, err error) {
 	kac.SetKeepAlive(true)
 	kac.SetKeepAlivePeriod(30 * time.Second)
 	c = tls.Server(c, l.config)
-	return
+	return c, nil
 }
 
 // NewListener creates a Listener which accepts connections from an inner
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/listener.go b/vendor/github.com/coreos/etcd/pkg/transport/listener.go
index 9dac85ade86..48655063f6f 100644
--- a/vendor/github.com/coreos/etcd/pkg/transport/listener.go
+++ b/vendor/github.com/coreos/etcd/pkg/transport/listener.go
@@ -22,6 +22,7 @@ import (
 	"crypto/x509"
 	"crypto/x509/pkix"
 	"encoding/pem"
+	"errors"
 	"fmt"
 	"math/big"
 	"net"
@@ -52,15 +53,17 @@ func wrapTLS(addr, scheme string, tlsinfo *TLSInfo, l net.Listener) (net.Listene
 	if scheme != "https" && scheme != "unixs" {
 		return l, nil
 	}
-	return newTLSListener(l, tlsinfo)
+	return newTLSListener(l, tlsinfo, checkSAN)
 }
 
 type TLSInfo struct {
-	CertFile       string
-	KeyFile        string
-	CAFile         string
-	TrustedCAFile  string
-	ClientCertAuth bool
+	CertFile           string
+	KeyFile            string
+	CAFile             string // TODO: deprecate this in v4
+	TrustedCAFile      string
+	ClientCertAuth     bool
+	CRLFile            string
+	InsecureSkipVerify bool
 
 	// ServerName ensures the cert matches the given host in case of discovery / virtual hosting
 	ServerName string
@@ -79,10 +82,13 @@ type TLSInfo struct {
 	// parseFunc exists to simplify testing. Typically, parseFunc
 	// should be left nil. In that case, tls.X509KeyPair will be used.
 	parseFunc func([]byte, []byte) (tls.Certificate, error)
+
+	// AllowedCN is a CN which must be provided by a client.
+	AllowedCN string
 }
 
 func (info TLSInfo) String() string {
-	return fmt.Sprintf("cert = %s, key = %s, ca = %s, trusted-ca = %s, client-cert-auth = %v", info.CertFile, info.KeyFile, info.CAFile, info.TrustedCAFile, info.ClientCertAuth)
+	return fmt.Sprintf("cert = %s, key = %s, ca = %s, trusted-ca = %s, client-cert-auth = %v, crl-file = %s", info.CertFile, info.KeyFile, info.CAFile, info.TrustedCAFile, info.ClientCertAuth, info.CRLFile)
 }
 
 func (info TLSInfo) Empty() bool {
@@ -181,6 +187,19 @@ func (info TLSInfo) baseConfig() (*tls.Config, error) {
 		cfg.CipherSuites = info.CipherSuites
 	}
 
+	if info.AllowedCN != "" {
+		cfg.VerifyPeerCertificate = func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
+			for _, chains := range verifiedChains {
+				if len(chains) != 0 {
+					if info.AllowedCN == chains[0].Subject.CommonName {
+						return nil
+					}
+				}
+			}
+			return errors.New("CommonName authentication failed")
+		}
+	}
+
 	// this only reloads certs when there's a client request
 	// TODO: support server-side refresh (e.g. inotify, SIGHUP), caching
 	cfg.GetCertificate = func(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
@@ -244,6 +263,7 @@ func (info TLSInfo) ClientConfig() (*tls.Config, error) {
 	} else {
 		cfg = &tls.Config{ServerName: info.ServerName}
 	}
+	cfg.InsecureSkipVerify = info.InsecureSkipVerify
 
 	CAFiles := info.cafiles()
 	if len(CAFiles) > 0 {
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/listener_tls.go b/vendor/github.com/coreos/etcd/pkg/transport/listener_tls.go
index 86511860335..6f1600945cc 100644
--- a/vendor/github.com/coreos/etcd/pkg/transport/listener_tls.go
+++ b/vendor/github.com/coreos/etcd/pkg/transport/listener_tls.go
@@ -19,22 +19,33 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"fmt"
+	"io/ioutil"
 	"net"
 	"strings"
 	"sync"
 )
 
 // tlsListener overrides a TLS listener so it will reject client
-// certificates with insufficient SAN credentials.
+// certificates with insufficient SAN credentials or CRL revoked
+// certificates.
 type tlsListener struct {
 	net.Listener
 	connc            chan net.Conn
 	donec            chan struct{}
 	err              error
 	handshakeFailure func(*tls.Conn, error)
+	check            tlsCheckFunc
 }
 
-func newTLSListener(l net.Listener, tlsinfo *TLSInfo) (net.Listener, error) {
+type tlsCheckFunc func(context.Context, *tls.Conn) error
+
+// NewTLSListener handshakes TLS connections and performs optional CRL checking.
+func NewTLSListener(l net.Listener, tlsinfo *TLSInfo) (net.Listener, error) {
+	check := func(context.Context, *tls.Conn) error { return nil }
+	return newTLSListener(l, tlsinfo, check)
+}
+
+func newTLSListener(l net.Listener, tlsinfo *TLSInfo, check tlsCheckFunc) (net.Listener, error) {
 	if tlsinfo == nil || tlsinfo.Empty() {
 		l.Close()
 		return nil, fmt.Errorf("cannot listen on TLS for %s: KeyFile and CertFile are not presented", l.Addr().String())
@@ -48,11 +59,27 @@ func newTLSListener(l net.Listener, tlsinfo *TLSInfo) (net.Listener, error) {
 	if hf == nil {
 		hf = func(*tls.Conn, error) {}
 	}
+
+	if len(tlsinfo.CRLFile) > 0 {
+		prevCheck := check
+		check = func(ctx context.Context, tlsConn *tls.Conn) error {
+			if err := prevCheck(ctx, tlsConn); err != nil {
+				return err
+			}
+			st := tlsConn.ConnectionState()
+			if certs := st.PeerCertificates; len(certs) > 0 {
+				return checkCRL(tlsinfo.CRLFile, certs)
+			}
+			return nil
+		}
+	}
+
 	tlsl := &tlsListener{
 		Listener:         tls.NewListener(l, tlscfg),
 		connc:            make(chan net.Conn),
 		donec:            make(chan struct{}),
 		handshakeFailure: hf,
+		check:            check,
 	}
 	go tlsl.acceptLoop()
 	return tlsl, nil
@@ -67,6 +94,15 @@ func (l *tlsListener) Accept() (net.Conn, error) {
 	}
 }
 
+func checkSAN(ctx context.Context, tlsConn *tls.Conn) error {
+	st := tlsConn.ConnectionState()
+	if certs := st.PeerCertificates; len(certs) > 0 {
+		addr := tlsConn.RemoteAddr().String()
+		return checkCertSAN(ctx, certs[0], addr)
+	}
+	return nil
+}
+
 // acceptLoop launches each TLS handshake in a separate goroutine
 // to prevent a hanging TLS connection from blocking other connections.
 func (l *tlsListener) acceptLoop() {
@@ -111,20 +147,16 @@ func (l *tlsListener) acceptLoop() {
 			pendingMu.Lock()
 			delete(pending, conn)
 			pendingMu.Unlock()
+
 			if herr != nil {
 				l.handshakeFailure(tlsConn, herr)
 				return
 			}
-
-			st := tlsConn.ConnectionState()
-			if len(st.PeerCertificates) > 0 {
-				cert := st.PeerCertificates[0]
-				addr := tlsConn.RemoteAddr().String()
-				if cerr := checkCert(ctx, cert, addr); cerr != nil {
-					l.handshakeFailure(tlsConn, cerr)
-					return
-				}
+			if err := l.check(ctx, tlsConn); err != nil {
+				l.handshakeFailure(tlsConn, err)
+				return
 			}
+
 			select {
 			case l.connc <- tlsConn:
 				conn = nil
@@ -134,11 +166,34 @@ func (l *tlsListener) acceptLoop() {
 	}
 }
 
-func checkCert(ctx context.Context, cert *x509.Certificate, remoteAddr string) error {
-	h, _, herr := net.SplitHostPort(remoteAddr)
+func checkCRL(crlPath string, cert []*x509.Certificate) error {
+	// TODO: cache
+	crlBytes, err := ioutil.ReadFile(crlPath)
+	if err != nil {
+		return err
+	}
+	certList, err := x509.ParseCRL(crlBytes)
+	if err != nil {
+		return err
+	}
+	revokedSerials := make(map[string]struct{})
+	for _, rc := range certList.TBSCertList.RevokedCertificates {
+		revokedSerials[string(rc.SerialNumber.Bytes())] = struct{}{}
+	}
+	for _, c := range cert {
+		serial := string(c.SerialNumber.Bytes())
+		if _, ok := revokedSerials[serial]; ok {
+			return fmt.Errorf("transport: certificate serial %x revoked", serial)
+		}
+	}
+	return nil
+}
+
+func checkCertSAN(ctx context.Context, cert *x509.Certificate, remoteAddr string) error {
 	if len(cert.IPAddresses) == 0 && len(cert.DNSNames) == 0 {
 		return nil
 	}
+	h, _, herr := net.SplitHostPort(remoteAddr)
 	if herr != nil {
 		return herr
 	}
diff --git a/vendor/github.com/coreos/etcd/pkg/types/set.go b/vendor/github.com/coreos/etcd/pkg/types/set.go
index 73ef431bef1..c111b0c0c0b 100644
--- a/vendor/github.com/coreos/etcd/pkg/types/set.go
+++ b/vendor/github.com/coreos/etcd/pkg/types/set.go
@@ -61,7 +61,7 @@ func (us *unsafeSet) Remove(value string) {
 // Contains returns whether the set contains the given value
 func (us *unsafeSet) Contains(value string) (exists bool) {
 	_, exists = us.d[value]
-	return
+	return exists
 }
 
 // ContainsAll returns whether the set contains all given values
@@ -94,7 +94,7 @@ func (us *unsafeSet) Values() (values []string) {
 	for val := range us.d {
 		values = append(values, val)
 	}
-	return
+	return values
 }
 
 // Copy creates a new Set containing the values of the first
diff --git a/vendor/github.com/coreos/etcd/pkg/wait/wait.go b/vendor/github.com/coreos/etcd/pkg/wait/wait.go
index 34fa237e825..9b1df419e29 100644
--- a/vendor/github.com/coreos/etcd/pkg/wait/wait.go
+++ b/vendor/github.com/coreos/etcd/pkg/wait/wait.go
@@ -34,7 +34,7 @@ type Wait interface {
 }
 
 type list struct {
-	l sync.Mutex
+	l sync.RWMutex
 	m map[uint64]chan interface{}
 }
 
@@ -68,8 +68,8 @@ func (w *list) Trigger(id uint64, x interface{}) {
 }
 
 func (w *list) IsRegistered(id uint64) bool {
-	w.l.Lock()
-	defer w.l.Unlock()
+	w.l.RLock()
+	defer w.l.RUnlock()
 	_, ok := w.m[id]
 	return ok
 }
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/BUILD b/vendor/github.com/coreos/etcd/proxy/grpcproxy/BUILD
index 500a359487b..c2e9dc452ea 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/BUILD
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/BUILD
@@ -7,6 +7,7 @@ go_library(
         "cluster.go",
         "doc.go",
         "election.go",
+        "health.go",
         "kv.go",
         "leader.go",
         "lease.go",
@@ -15,6 +16,7 @@ go_library(
         "maintenance.go",
         "metrics.go",
         "register.go",
+        "util.go",
         "watch.go",
         "watch_broadcast.go",
         "watch_broadcasts.go",
@@ -28,6 +30,7 @@ go_library(
         "//vendor/github.com/coreos/etcd/clientv3:go_default_library",
         "//vendor/github.com/coreos/etcd/clientv3/concurrency:go_default_library",
         "//vendor/github.com/coreos/etcd/clientv3/naming:go_default_library",
+        "//vendor/github.com/coreos/etcd/etcdserver/api/etcdhttp:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3rpc:go_default_library",
@@ -38,7 +41,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/proxy/grpcproxy/cache:go_default_library",
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
         "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
         "//vendor/golang.org/x/time/rate:go_default_library",
         "//vendor/google.golang.org/grpc:go_default_library",
         "//vendor/google.golang.org/grpc/metadata:go_default_library",
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/BUILD b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/BUILD
index 8c9d45bdd2e..ef041d4e12c 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/BUILD
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/BUILD
@@ -3,6 +3,7 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     srcs = [
+        "auth_client_adapter.go",
         "chan_stream.go",
         "cluster_client_adapter.go",
         "doc.go",
@@ -20,7 +21,6 @@ go_library(
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb:go_default_library",
         "//vendor/github.com/coreos/etcd/etcdserver/etcdserverpb:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
         "//vendor/google.golang.org/grpc:go_default_library",
         "//vendor/google.golang.org/grpc/metadata:go_default_library",
     ],
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/auth_client_adapter.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/auth_client_adapter.go
new file mode 100644
index 00000000000..33dc91f013f
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/auth_client_adapter.go
@@ -0,0 +1,93 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package adapter
+
+import (
+	"context"
+
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+
+	grpc "google.golang.org/grpc"
+)
+
+type as2ac struct{ as pb.AuthServer }
+
+func AuthServerToAuthClient(as pb.AuthServer) pb.AuthClient {
+	return &as2ac{as}
+}
+
+func (s *as2ac) AuthEnable(ctx context.Context, in *pb.AuthEnableRequest, opts ...grpc.CallOption) (*pb.AuthEnableResponse, error) {
+	return s.as.AuthEnable(ctx, in)
+}
+
+func (s *as2ac) AuthDisable(ctx context.Context, in *pb.AuthDisableRequest, opts ...grpc.CallOption) (*pb.AuthDisableResponse, error) {
+	return s.as.AuthDisable(ctx, in)
+}
+
+func (s *as2ac) Authenticate(ctx context.Context, in *pb.AuthenticateRequest, opts ...grpc.CallOption) (*pb.AuthenticateResponse, error) {
+	return s.as.Authenticate(ctx, in)
+}
+
+func (s *as2ac) RoleAdd(ctx context.Context, in *pb.AuthRoleAddRequest, opts ...grpc.CallOption) (*pb.AuthRoleAddResponse, error) {
+	return s.as.RoleAdd(ctx, in)
+}
+
+func (s *as2ac) RoleDelete(ctx context.Context, in *pb.AuthRoleDeleteRequest, opts ...grpc.CallOption) (*pb.AuthRoleDeleteResponse, error) {
+	return s.as.RoleDelete(ctx, in)
+}
+
+func (s *as2ac) RoleGet(ctx context.Context, in *pb.AuthRoleGetRequest, opts ...grpc.CallOption) (*pb.AuthRoleGetResponse, error) {
+	return s.as.RoleGet(ctx, in)
+}
+
+func (s *as2ac) RoleList(ctx context.Context, in *pb.AuthRoleListRequest, opts ...grpc.CallOption) (*pb.AuthRoleListResponse, error) {
+	return s.as.RoleList(ctx, in)
+}
+
+func (s *as2ac) RoleRevokePermission(ctx context.Context, in *pb.AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (*pb.AuthRoleRevokePermissionResponse, error) {
+	return s.as.RoleRevokePermission(ctx, in)
+}
+
+func (s *as2ac) RoleGrantPermission(ctx context.Context, in *pb.AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (*pb.AuthRoleGrantPermissionResponse, error) {
+	return s.as.RoleGrantPermission(ctx, in)
+}
+
+func (s *as2ac) UserDelete(ctx context.Context, in *pb.AuthUserDeleteRequest, opts ...grpc.CallOption) (*pb.AuthUserDeleteResponse, error) {
+	return s.as.UserDelete(ctx, in)
+}
+
+func (s *as2ac) UserAdd(ctx context.Context, in *pb.AuthUserAddRequest, opts ...grpc.CallOption) (*pb.AuthUserAddResponse, error) {
+	return s.as.UserAdd(ctx, in)
+}
+
+func (s *as2ac) UserGet(ctx context.Context, in *pb.AuthUserGetRequest, opts ...grpc.CallOption) (*pb.AuthUserGetResponse, error) {
+	return s.as.UserGet(ctx, in)
+}
+
+func (s *as2ac) UserList(ctx context.Context, in *pb.AuthUserListRequest, opts ...grpc.CallOption) (*pb.AuthUserListResponse, error) {
+	return s.as.UserList(ctx, in)
+}
+
+func (s *as2ac) UserGrantRole(ctx context.Context, in *pb.AuthUserGrantRoleRequest, opts ...grpc.CallOption) (*pb.AuthUserGrantRoleResponse, error) {
+	return s.as.UserGrantRole(ctx, in)
+}
+
+func (s *as2ac) UserRevokeRole(ctx context.Context, in *pb.AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (*pb.AuthUserRevokeRoleResponse, error) {
+	return s.as.UserRevokeRole(ctx, in)
+}
+
+func (s *as2ac) UserChangePassword(ctx context.Context, in *pb.AuthUserChangePasswordRequest, opts ...grpc.CallOption) (*pb.AuthUserChangePasswordResponse, error) {
+	return s.as.UserChangePassword(ctx, in)
+}
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/chan_stream.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/chan_stream.go
index 3aa01f2052b..82e34119311 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/chan_stream.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/chan_stream.go
@@ -15,7 +15,7 @@
 package adapter
 
 import (
-	"golang.org/x/net/context"
+	"context"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/cluster_client_adapter.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/cluster_client_adapter.go
index 4ddf78e15ec..6c0340998b9 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/cluster_client_adapter.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/cluster_client_adapter.go
@@ -15,9 +15,10 @@
 package adapter
 
 import (
+	"context"
+
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/election_client_adapter.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/election_client_adapter.go
index 383c1b9d8fb..a2ebf138f3b 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/election_client_adapter.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/election_client_adapter.go
@@ -15,9 +15,10 @@
 package adapter
 
 import (
+	"context"
+
 	"github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/kv_client_adapter.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/kv_client_adapter.go
index fec401d9dd0..acd5673d005 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/kv_client_adapter.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/kv_client_adapter.go
@@ -15,8 +15,10 @@
 package adapter
 
 import (
+	"context"
+
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	"golang.org/x/net/context"
+
 	grpc "google.golang.org/grpc"
 )
 
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/lease_client_adapter.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/lease_client_adapter.go
index d471fd9144b..84c48b591b0 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/lease_client_adapter.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/lease_client_adapter.go
@@ -15,9 +15,10 @@
 package adapter
 
 import (
-	"golang.org/x/net/context"
+	"context"
 
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+
 	"google.golang.org/grpc"
 )
 
@@ -48,6 +49,10 @@ func (c *ls2lc) LeaseTimeToLive(ctx context.Context, in *pb.LeaseTimeToLiveReque
 	return c.leaseServer.LeaseTimeToLive(ctx, in)
 }
 
+func (c *ls2lc) LeaseLeases(ctx context.Context, in *pb.LeaseLeasesRequest, opts ...grpc.CallOption) (*pb.LeaseLeasesResponse, error) {
+	return c.leaseServer.LeaseLeases(ctx, in)
+}
+
 // ls2lcClientStream implements Lease_LeaseKeepAliveClient
 type ls2lcClientStream struct{ chanClientStream }
 
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/lock_client_adapter.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/lock_client_adapter.go
index 05e5cb020a1..9ce7913a3ba 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/lock_client_adapter.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/lock_client_adapter.go
@@ -15,9 +15,10 @@
 package adapter
 
 import (
+	"context"
+
 	"github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/maintenance_client_adapter.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/maintenance_client_adapter.go
index 9b21bf2576e..92d9dfd204e 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/maintenance_client_adapter.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/maintenance_client_adapter.go
@@ -15,9 +15,10 @@
 package adapter
 
 import (
+	"context"
+
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
@@ -43,6 +44,14 @@ func (s *mts2mtc) Hash(ctx context.Context, r *pb.HashRequest, opts ...grpc.Call
 	return s.mts.Hash(ctx, r)
 }
 
+func (s *mts2mtc) HashKV(ctx context.Context, r *pb.HashKVRequest, opts ...grpc.CallOption) (*pb.HashKVResponse, error) {
+	return s.mts.HashKV(ctx, r)
+}
+
+func (s *mts2mtc) MoveLeader(ctx context.Context, r *pb.MoveLeaderRequest, opts ...grpc.CallOption) (*pb.MoveLeaderResponse, error) {
+	return s.mts.MoveLeader(ctx, r)
+}
+
 func (s *mts2mtc) Snapshot(ctx context.Context, in *pb.SnapshotRequest, opts ...grpc.CallOption) (pb.Maintenance_SnapshotClient, error) {
 	cs := newPipeStream(ctx, func(ss chanServerStream) error {
 		return s.mts.Snapshot(in, &ss2scServerStream{ss})
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/watch_client_adapter.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/watch_client_adapter.go
index af4a13c4152..afe61e837b5 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/watch_client_adapter.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/adapter/watch_client_adapter.go
@@ -15,10 +15,10 @@
 package adapter
 
 import (
+	"context"
 	"errors"
 
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/auth.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/auth.go
index c1b75e36dbd..0ed8d246d2b 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/auth.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/auth.go
@@ -15,7 +15,7 @@
 package grpcproxy
 
 import (
-	"golang.org/x/net/context"
+	"context"
 
 	"github.com/coreos/etcd/clientv3"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/cache/store.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/cache/store.go
index e84a05229e0..70715e499d8 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/cache/store.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/cache/store.go
@@ -40,7 +40,7 @@ type Cache interface {
 	Close()
 }
 
-// keyFunc returns the key of an request, which is used to look up in the cache for it's caching response.
+// keyFunc returns the key of a request, which is used to look up its caching response in the cache.
 func keyFunc(req *pb.RangeRequest) string {
 	// TODO: use marshalTo to reduce allocation
 	b, err := req.Marshal()
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/cluster.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/cluster.go
index 899fb9be65f..6e8d3c85bfb 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/cluster.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/cluster.go
@@ -15,17 +15,17 @@
 package grpcproxy
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"sync"
 
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/clientv3/naming"
+	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 
-	"golang.org/x/net/context"
 	"golang.org/x/time/rate"
-	"google.golang.org/grpc"
 	gnaming "google.golang.org/grpc/naming"
 )
 
@@ -89,7 +89,7 @@ func (cp *clusterProxy) monitor(wa gnaming.Watcher) {
 		ups, err := wa.Next()
 		if err != nil {
 			plog.Warningf("clusterProxy watcher error (%v)", err)
-			if grpc.ErrorDesc(err) == naming.ErrWatcherClosed.Error() {
+			if rpctypes.ErrorDesc(err) == naming.ErrWatcherClosed.Error() {
 				return
 			}
 		}
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/election.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/election.go
index 27115a81d7d..4b4a4cc4210 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/election.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/election.go
@@ -15,7 +15,7 @@
 package grpcproxy
 
 import (
-	"golang.org/x/net/context"
+	"context"
 
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/etcdserver/api/v3election/v3electionpb"
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/health.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/health.go
new file mode 100644
index 00000000000..e5e91f29bb3
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/health.go
@@ -0,0 +1,41 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package grpcproxy
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/coreos/etcd/clientv3"
+	"github.com/coreos/etcd/etcdserver/api/etcdhttp"
+	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
+)
+
+// HandleHealth registers health handler on '/health'.
+func HandleHealth(mux *http.ServeMux, c *clientv3.Client) {
+	mux.Handle(etcdhttp.PathHealth, etcdhttp.NewHealthHandler(func() etcdhttp.Health { return checkHealth(c) }))
+}
+
+func checkHealth(c *clientv3.Client) etcdhttp.Health {
+	h := etcdhttp.Health{Health: "false"}
+	ctx, cancel := context.WithTimeout(c.Ctx(), time.Second)
+	_, err := c.Get(ctx, "a")
+	cancel()
+	if err == nil || err == rpctypes.ErrPermissionDenied {
+		h.Health = "true"
+	}
+	return h
+}
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/kv.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/kv.go
index 0654729a0ae..1c9860f98af 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/kv.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/kv.go
@@ -15,11 +15,11 @@
 package grpcproxy
 
 import (
+	"context"
+
 	"github.com/coreos/etcd/clientv3"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/proxy/grpcproxy/cache"
-
-	"golang.org/x/net/context"
 )
 
 type kvProxy struct {
@@ -48,8 +48,9 @@ func (p *kvProxy) Range(ctx context.Context, r *pb.RangeRequest) (*pb.RangeRespo
 			cacheHits.Inc()
 			return nil, err
 		}
+
+		cachedMisses.Inc()
 	}
-	cachedMisses.Inc()
 
 	resp, err := p.kv.Do(ctx, RangeRequestToOp(r))
 	if err != nil {
@@ -99,31 +100,16 @@ func (p *kvProxy) txnToCache(reqs []*pb.RequestOp, resps []*pb.ResponseOp) {
 }
 
 func (p *kvProxy) Txn(ctx context.Context, r *pb.TxnRequest) (*pb.TxnResponse, error) {
-	txn := p.kv.Txn(ctx)
-	cmps := make([]clientv3.Cmp, len(r.Compare))
-	thenops := make([]clientv3.Op, len(r.Success))
-	elseops := make([]clientv3.Op, len(r.Failure))
-
-	for i := range r.Compare {
-		cmps[i] = (clientv3.Cmp)(*r.Compare[i])
-	}
-
-	for i := range r.Success {
-		thenops[i] = requestOpToOp(r.Success[i])
-	}
-
-	for i := range r.Failure {
-		elseops[i] = requestOpToOp(r.Failure[i])
-	}
-
-	resp, err := txn.If(cmps...).Then(thenops...).Else(elseops...).Commit()
-
+	op := TxnRequestToOp(r)
+	opResp, err := p.kv.Do(ctx, op)
 	if err != nil {
 		return nil, err
 	}
+	resp := opResp.Txn()
+
 	// txn may claim an outdated key is updated; be safe and invalidate
 	for _, cmp := range r.Compare {
-		p.cache.Invalidate(cmp.Key, nil)
+		p.cache.Invalidate(cmp.Key, cmp.RangeEnd)
 	}
 	// update any fetched keys
 	if resp.Succeeded {
@@ -167,6 +153,10 @@ func requestOpToOp(union *pb.RequestOp) clientv3.Op {
 		if tv.RequestDeleteRange != nil {
 			return DelRequestToOp(tv.RequestDeleteRange)
 		}
+	case *pb.RequestOp_RequestTxn:
+		if tv.RequestTxn != nil {
+			return TxnRequestToOp(tv.RequestTxn)
+		}
 	}
 	panic("unknown request")
 }
@@ -224,3 +214,19 @@ func DelRequestToOp(r *pb.DeleteRangeRequest) clientv3.Op {
 	}
 	return clientv3.OpDelete(string(r.Key), opts...)
 }
+
+func TxnRequestToOp(r *pb.TxnRequest) clientv3.Op {
+	cmps := make([]clientv3.Cmp, len(r.Compare))
+	thenops := make([]clientv3.Op, len(r.Success))
+	elseops := make([]clientv3.Op, len(r.Failure))
+	for i := range r.Compare {
+		cmps[i] = (clientv3.Cmp)(*r.Compare[i])
+	}
+	for i := range r.Success {
+		thenops[i] = requestOpToOp(r.Success[i])
+	}
+	for i := range r.Failure {
+		elseops[i] = requestOpToOp(r.Failure[i])
+	}
+	return clientv3.OpTxn(cmps, thenops, elseops)
+}
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/leader.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/leader.go
index 86afdb7072b..042c949b708 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/leader.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/leader.go
@@ -15,14 +15,15 @@
 package grpcproxy
 
 import (
+	"context"
 	"math"
 	"sync"
 
-	"golang.org/x/net/context"
+	"github.com/coreos/etcd/clientv3"
+	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
+
 	"golang.org/x/time/rate"
 	"google.golang.org/grpc"
-
-	"github.com/coreos/etcd/clientv3"
 )
 
 const (
@@ -68,7 +69,7 @@ func (l *leader) recvLoop() {
 		}
 		if cresp.Err() != nil {
 			l.loseLeader()
-			if grpc.ErrorDesc(cresp.Err()) == grpc.ErrClientConnClosing.Error() {
+			if rpctypes.ErrorDesc(cresp.Err()) == grpc.ErrClientConnClosing.Error() {
 				close(l.disconnc)
 				return
 			}
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/lease.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/lease.go
index 19c2249a7e2..65f68b0ea0c 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/lease.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/lease.go
@@ -15,19 +15,18 @@
 package grpcproxy
 
 import (
+	"context"
 	"io"
 	"sync"
 	"sync/atomic"
 	"time"
 
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
-
-	"golang.org/x/net/context"
-
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
 )
 
 type leaseProxy struct {
@@ -73,7 +72,7 @@ func NewLeaseProxy(c *clientv3.Client) (pb.LeaseServer, <-chan struct{}) {
 }
 
 func (lp *leaseProxy) LeaseGrant(ctx context.Context, cr *pb.LeaseGrantRequest) (*pb.LeaseGrantResponse, error) {
-	rp, err := lp.leaseClient.LeaseGrant(ctx, cr)
+	rp, err := lp.leaseClient.LeaseGrant(ctx, cr, grpc.FailFast(false))
 	if err != nil {
 		return nil, err
 	}
@@ -113,6 +112,22 @@ func (lp *leaseProxy) LeaseTimeToLive(ctx context.Context, rr *pb.LeaseTimeToLiv
 	return rp, err
 }
 
+func (lp *leaseProxy) LeaseLeases(ctx context.Context, rr *pb.LeaseLeasesRequest) (*pb.LeaseLeasesResponse, error) {
+	r, err := lp.lessor.Leases(ctx)
+	if err != nil {
+		return nil, err
+	}
+	leases := make([]*pb.LeaseStatus, len(r.Leases))
+	for i := range r.Leases {
+		leases[i] = &pb.LeaseStatus{ID: int64(r.Leases[i].ID)}
+	}
+	rp := &pb.LeaseLeasesResponse{
+		Header: r.ResponseHeader,
+		Leases: leases,
+	}
+	return rp, err
+}
+
 func (lp *leaseProxy) LeaseKeepAlive(stream pb.Lease_LeaseKeepAliveServer) error {
 	lp.mu.Lock()
 	select {
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/lock.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/lock.go
index 804aff64a96..ceef26f0a0f 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/lock.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/lock.go
@@ -15,7 +15,7 @@
 package grpcproxy
 
 import (
-	"golang.org/x/net/context"
+	"context"
 
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/etcdserver/api/v3lock/v3lockpb"
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/maintenance.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/maintenance.go
index 384d1520360..291e8e3088f 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/maintenance.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/maintenance.go
@@ -15,10 +15,9 @@
 package grpcproxy
 
 import (
+	"context"
 	"io"
 
-	"golang.org/x/net/context"
-
 	"github.com/coreos/etcd/clientv3"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 )
@@ -43,6 +42,8 @@ func (mp *maintenanceProxy) Snapshot(sr *pb.SnapshotRequest, stream pb.Maintenan
 	ctx, cancel := context.WithCancel(stream.Context())
 	defer cancel()
 
+	ctx = withClientAuthToken(ctx, stream.Context())
+
 	sc, err := pb.NewMaintenanceClient(conn).Snapshot(ctx, sr)
 	if err != nil {
 		return err
@@ -68,6 +69,11 @@ func (mp *maintenanceProxy) Hash(ctx context.Context, r *pb.HashRequest) (*pb.Ha
 	return pb.NewMaintenanceClient(conn).Hash(ctx, r)
 }
 
+func (mp *maintenanceProxy) HashKV(ctx context.Context, r *pb.HashKVRequest) (*pb.HashKVResponse, error) {
+	conn := mp.client.ActiveConnection()
+	return pb.NewMaintenanceClient(conn).HashKV(ctx, r)
+}
+
 func (mp *maintenanceProxy) Alarm(ctx context.Context, r *pb.AlarmRequest) (*pb.AlarmResponse, error) {
 	conn := mp.client.ActiveConnection()
 	return pb.NewMaintenanceClient(conn).Alarm(ctx, r)
@@ -77,3 +83,8 @@ func (mp *maintenanceProxy) Status(ctx context.Context, r *pb.StatusRequest) (*p
 	conn := mp.client.ActiveConnection()
 	return pb.NewMaintenanceClient(conn).Status(ctx, r)
 }
+
+func (mp *maintenanceProxy) MoveLeader(ctx context.Context, r *pb.MoveLeaderRequest) (*pb.MoveLeaderResponse, error) {
+	conn := mp.client.ActiveConnection()
+	return pb.NewMaintenanceClient(conn).MoveLeader(ctx, r)
+}
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/util.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/util.go
new file mode 100644
index 00000000000..2b226fa74eb
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/util.go
@@ -0,0 +1,73 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package grpcproxy
+
+import (
+	"context"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+func getAuthTokenFromClient(ctx context.Context) string {
+	md, ok := metadata.FromIncomingContext(ctx)
+	if ok {
+		ts, ok := md["token"]
+		if ok {
+			return ts[0]
+		}
+	}
+	return ""
+}
+
+func withClientAuthToken(ctx context.Context, ctxWithToken context.Context) context.Context {
+	token := getAuthTokenFromClient(ctxWithToken)
+	if token != "" {
+		ctx = context.WithValue(ctx, "token", token)
+	}
+	return ctx
+}
+
+type proxyTokenCredential struct {
+	token string
+}
+
+func (cred *proxyTokenCredential) RequireTransportSecurity() bool {
+	return false
+}
+
+func (cred *proxyTokenCredential) GetRequestMetadata(ctx context.Context, s ...string) (map[string]string, error) {
+	return map[string]string{
+		"token": cred.token,
+	}, nil
+}
+
+func AuthUnaryClientInterceptor(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
+	token := getAuthTokenFromClient(ctx)
+	if token != "" {
+		tokenCred := &proxyTokenCredential{token}
+		opts = append(opts, grpc.PerRPCCredentials(tokenCred))
+	}
+	return invoker(ctx, method, req, reply, cc, opts...)
+}
+
+func AuthStreamClientInterceptor(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
+	tokenif := ctx.Value("token")
+	if tokenif != nil {
+		tokenCred := &proxyTokenCredential{tokenif.(string)}
+		opts = append(opts, grpc.PerRPCCredentials(tokenCred))
+	}
+	return streamer(ctx, desc, cc, method, opts...)
+}
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/watch.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/watch.go
index b960c94769a..603095f27f1 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/watch.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/watch.go
@@ -15,16 +15,16 @@
 package grpcproxy
 
 import (
+	"context"
 	"sync"
 
-	"golang.org/x/net/context"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
-
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
 )
 
 type watchProxy struct {
@@ -40,6 +40,9 @@ type watchProxy struct {
 
 	// wg waits until all outstanding watch servers quit.
 	wg sync.WaitGroup
+
+	// kv is used for permission checking
+	kv clientv3.KV
 }
 
 func NewWatchProxy(c *clientv3.Client) (pb.WatchServer, <-chan struct{}) {
@@ -48,6 +51,8 @@ func NewWatchProxy(c *clientv3.Client) (pb.WatchServer, <-chan struct{}) {
 		cw:     c.Watcher,
 		ctx:    cctx,
 		leader: newLeader(c.Ctx(), c.Watcher),
+
+		kv: c.KV, // for permission checking
 	}
 	wp.ranges = newWatchRanges(wp)
 	ch := make(chan struct{})
@@ -92,6 +97,7 @@ func (wp *watchProxy) Watch(stream pb.Watch_WatchServer) (err error) {
 		watchCh:  make(chan *pb.WatchResponse, 1024),
 		ctx:      ctx,
 		cancel:   cancel,
+		kv:       wp.kv,
 	}
 
 	var lostLeaderC <-chan struct{}
@@ -171,6 +177,9 @@ type watchProxyStream struct {
 
 	ctx    context.Context
 	cancel context.CancelFunc
+
+	// kv is used for permission checking
+	kv clientv3.KV
 }
 
 func (wps *watchProxyStream) close() {
@@ -192,6 +201,24 @@ func (wps *watchProxyStream) close() {
 	close(wps.watchCh)
 }
 
+func (wps *watchProxyStream) checkPermissionForWatch(key, rangeEnd []byte) error {
+	if len(key) == 0 {
+		// If the length of the key is 0, we need to obtain full range.
+		// look at clientv3.WithPrefix()
+		key = []byte{0}
+		rangeEnd = []byte{0}
+	}
+	req := &pb.RangeRequest{
+		Serializable: true,
+		Key:          key,
+		RangeEnd:     rangeEnd,
+		CountOnly:    true,
+		Limit:        1,
+	}
+	_, err := wps.kv.Do(wps.ctx, RangeRequestToOp(req))
+	return err
+}
+
 func (wps *watchProxyStream) recvLoop() error {
 	for {
 		req, err := wps.stream.Recv()
@@ -201,6 +228,15 @@ func (wps *watchProxyStream) recvLoop() error {
 		switch uv := req.RequestUnion.(type) {
 		case *pb.WatchRequest_CreateRequest:
 			cr := uv.CreateRequest
+
+			if err = wps.checkPermissionForWatch(cr.Key, cr.RangeEnd); err != nil && err == rpctypes.ErrPermissionDenied {
+				// Return WatchResponse which is caused by permission checking if and only if
+				// the error is permission denied. For other errors (e.g. timeout or connection closed),
+				// the permission checking mechanism should do nothing for preserving error code.
+				wps.watchCh <- &pb.WatchResponse{Header: &pb.ResponseHeader{}, WatchId: -1, Created: true, Canceled: true}
+				continue
+			}
+
 			w := &watcher{
 				wr:  watchRange{string(cr.Key), string(cr.RangeEnd)},
 				id:  wps.nextWatcherID,
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/watch_broadcast.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/watch_broadcast.go
index 5e750bdb0d4..46e56c79a9d 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/watch_broadcast.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/watch_broadcast.go
@@ -15,10 +15,9 @@
 package grpcproxy
 
 import (
+	"context"
 	"sync"
 
-	"golang.org/x/net/context"
-
 	"github.com/coreos/etcd/clientv3"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 )
@@ -59,6 +58,8 @@ func newWatchBroadcast(wp *watchProxy, w *watcher, update func(*watchBroadcast))
 			clientv3.WithCreatedNotify(),
 		}
 
+		cctx = withClientAuthToken(cctx, w.wps.stream.Context())
+
 		wch := wp.cw.Watch(cctx, w.wr.key, opts...)
 
 		for wr := range wch {
diff --git a/vendor/github.com/coreos/etcd/proxy/grpcproxy/watcher.go b/vendor/github.com/coreos/etcd/proxy/grpcproxy/watcher.go
index 7387caf4dbd..1a497462f99 100644
--- a/vendor/github.com/coreos/etcd/proxy/grpcproxy/watcher.go
+++ b/vendor/github.com/coreos/etcd/proxy/grpcproxy/watcher.go
@@ -111,6 +111,7 @@ func (w *watcher) send(wr clientv3.WatchResponse) {
 		Header:          &wr.Header,
 		Created:         wr.Created,
 		CompactRevision: wr.CompactRevision,
+		Canceled:        wr.Canceled,
 		WatchId:         w.id,
 		Events:          events,
 	})
diff --git a/vendor/github.com/coreos/etcd/raft/BUILD b/vendor/github.com/coreos/etcd/raft/BUILD
index 9a72fb17b21..8738a4f6a37 100644
--- a/vendor/github.com/coreos/etcd/raft/BUILD
+++ b/vendor/github.com/coreos/etcd/raft/BUILD
@@ -19,10 +19,7 @@ go_library(
     importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/raft",
     importpath = "github.com/coreos/etcd/raft",
     visibility = ["//visibility:public"],
-    deps = [
-        "//vendor/github.com/coreos/etcd/raft/raftpb:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
-    ],
+    deps = ["//vendor/github.com/coreos/etcd/raft/raftpb:go_default_library"],
 )
 
 filegroup(
diff --git a/vendor/github.com/coreos/etcd/raft/README.md b/vendor/github.com/coreos/etcd/raft/README.md
index f485b839771..fde22b16519 100644
--- a/vendor/github.com/coreos/etcd/raft/README.md
+++ b/vendor/github.com/coreos/etcd/raft/README.md
@@ -25,12 +25,12 @@ This raft implementation is a full feature implementation of Raft protocol. Feat
 - Membership changes
 - Leadership transfer extension
 - Efficient linearizable read-only queries served by both the leader and followers
- - leader checks with quorum and bypasses Raft log before processing read-only queries
- - followers asks leader to get a safe read index before processing read-only queries
+  - leader checks with quorum and bypasses Raft log before processing read-only queries
+  - followers asks leader to get a safe read index before processing read-only queries
 - More efficient lease-based linearizable read-only queries served by both the leader and followers
- - leader bypasses Raft log and processing read-only queries locally
- - followers asks leader to get a safe read index before processing read-only queries
- - this approach relies on the clock of the all the machines in raft group
+  - leader bypasses Raft log and processing read-only queries locally
+  - followers asks leader to get a safe read index before processing read-only queries
+  - this approach relies on the clock of the all the machines in raft group
 
 This raft implementation also includes a few optional enhancements:
 
@@ -112,7 +112,7 @@ After creating a Node, the user has a few responsibilities:
 
 First, read from the Node.Ready() channel and process the updates it contains. These steps may be performed in parallel, except as noted in step 2.
 
-1. Write HardState, Entries, and Snapshot to persistent storage if they are not empty. Note that when writing an Entry with Index i, any previously-persisted entries with Index >= i must be discarded.
+1. Write Entries, HardState and Snapshot to persistent storage in order, i.e. Entries first, then HardState and Snapshot if they are not empty. If persistent storage supports atomic writes then all of them can be written together. Note that when writing an Entry with Index i, any previously-persisted entries with Index >= i must be discarded.
 
 2. Send all Messages to the nodes named in the To field. It is important that no messages be sent until the latest HardState has been persisted to disk, and all Entries written by any previous Ready batch (Messages may be sent while entries from the same batch are being persisted). To reduce the I/O latency, an optimization can be applied to make leader write to disk in parallel with its followers (as explained at section 10.2.1 in Raft thesis). If any Message has type MsgSnap, call Node.ReportSnapshot() after it has been sent (these messages may be large). Note: Marshalling messages is not thread-safe; it is important to make sure that no new entries are persisted while marshalling. The easiest way to achieve this is to serialise the messages directly inside the main raft loop.
 
diff --git a/vendor/github.com/coreos/etcd/raft/node.go b/vendor/github.com/coreos/etcd/raft/node.go
index 5da1c1193b2..33a9db84001 100644
--- a/vendor/github.com/coreos/etcd/raft/node.go
+++ b/vendor/github.com/coreos/etcd/raft/node.go
@@ -15,10 +15,10 @@
 package raft
 
 import (
+	"context"
 	"errors"
 
 	pb "github.com/coreos/etcd/raft/raftpb"
-	"golang.org/x/net/context"
 )
 
 type SnapshotStatus int
@@ -319,7 +319,7 @@ func (n *node) run(r *raft) {
 			r.Step(m)
 		case m := <-n.recvc:
 			// filter out response message from unknown From.
-			if _, ok := r.prs[m.From]; ok || !IsResponseMsg(m.Type) {
+			if pr := r.getProgress(m.From); pr != nil || !IsResponseMsg(m.Type) {
 				r.Step(m) // raft never returns an error
 			}
 		case cc := <-n.confc:
@@ -334,6 +334,8 @@ func (n *node) run(r *raft) {
 			switch cc.Type {
 			case pb.ConfChangeAddNode:
 				r.addNode(cc.NodeID)
+			case pb.ConfChangeAddLearnerNode:
+				r.addLearner(cc.NodeID)
 			case pb.ConfChangeRemoveNode:
 				// block incoming proposal when local node is
 				// removed
diff --git a/vendor/github.com/coreos/etcd/raft/progress.go b/vendor/github.com/coreos/etcd/raft/progress.go
index 77c7b52efe3..ef3787db65d 100644
--- a/vendor/github.com/coreos/etcd/raft/progress.go
+++ b/vendor/github.com/coreos/etcd/raft/progress.go
@@ -48,6 +48,7 @@ type Progress struct {
 	// When in ProgressStateSnapshot, leader should have sent out snapshot
 	// before and stops sending any replication message.
 	State ProgressStateType
+
 	// Paused is used in ProgressStateProbe.
 	// When Paused is true, raft should pause sending replication message to this peer.
 	Paused bool
@@ -76,6 +77,9 @@ type Progress struct {
 	// be freed by calling inflights.freeTo with the index of the last
 	// received entry.
 	ins *inflights
+
+	// IsLearner is true if this progress is tracked for a learner.
+	IsLearner bool
 }
 
 func (pr *Progress) resetState(state ProgressStateType) {
@@ -243,7 +247,8 @@ func (in *inflights) freeTo(to uint64) {
 		return
 	}
 
-	i, idx := 0, in.start
+	idx := in.start
+	var i int
 	for i = 0; i < in.count; i++ {
 		if to < in.buffer[idx] { // found the first large inflight
 			break
diff --git a/vendor/github.com/coreos/etcd/raft/raft.go b/vendor/github.com/coreos/etcd/raft/raft.go
index 29f20398203..b4c0f0248ca 100644
--- a/vendor/github.com/coreos/etcd/raft/raft.go
+++ b/vendor/github.com/coreos/etcd/raft/raft.go
@@ -116,6 +116,10 @@ type Config struct {
 	// used for testing right now.
 	peers []uint64
 
+	// learners contains the IDs of all leaner nodes (including self if the local node is a leaner) in the raft cluster.
+	// learners only receives entries from the leader node. It does not vote or promote itself.
+	learners []uint64
+
 	// ElectionTick is the number of Node.Tick invocations that must pass between
 	// elections. That is, if a follower does not receive any message from the
 	// leader of current term before ElectionTick has elapsed, it will become
@@ -171,11 +175,22 @@ type Config struct {
 	// If the clock drift is unbounded, leader might keep the lease longer than it
 	// should (clock can move backward/pause without any bound). ReadIndex is not safe
 	// in that case.
+	// CheckQuorum MUST be enabled if ReadOnlyOption is ReadOnlyLeaseBased.
 	ReadOnlyOption ReadOnlyOption
 
 	// Logger is the logger used for raft log. For multinode which can host
 	// multiple raft group, each raft group can have its own logger
 	Logger Logger
+
+	// DisableProposalForwarding set to true means that followers will drop
+	// proposals, rather than forwarding them to the leader. One use case for
+	// this feature would be in a situation where the Raft leader is used to
+	// compute the data of a proposal, for example, adding a timestamp from a
+	// hybrid logical clock to data in a monotonically increasing way. Forwarding
+	// should be disabled to prevent a follower with an innaccurate hybrid
+	// logical clock from assigning the timestamp and then forwarding the data
+	// to the leader.
+	DisableProposalForwarding bool
 }
 
 func (c *Config) validate() error {
@@ -203,6 +218,10 @@ func (c *Config) validate() error {
 		c.Logger = raftLogger
 	}
 
+	if c.ReadOnlyOption == ReadOnlyLeaseBased && !c.CheckQuorum {
+		return errors.New("CheckQuorum must be enabled when ReadOnlyOption is ReadOnlyLeaseBased")
+	}
+
 	return nil
 }
 
@@ -220,9 +239,13 @@ type raft struct {
 	maxInflight int
 	maxMsgSize  uint64
 	prs         map[uint64]*Progress
+	learnerPrs  map[uint64]*Progress
 
 	state StateType
 
+	// isLearner is true if the local raft node is a learner.
+	isLearner bool
+
 	votes map[uint64]bool
 
 	msgs []pb.Message
@@ -256,6 +279,7 @@ type raft struct {
 	// [electiontimeout, 2 * electiontimeout - 1]. It gets reset
 	// when raft changes its state to follower or candidate.
 	randomizedElectionTimeout int
+	disableProposalForwarding bool
 
 	tick func()
 	step stepFunc
@@ -273,32 +297,47 @@ func newRaft(c *Config) *raft {
 		panic(err) // TODO(bdarnell)
 	}
 	peers := c.peers
-	if len(cs.Nodes) > 0 {
-		if len(peers) > 0 {
+	learners := c.learners
+	if len(cs.Nodes) > 0 || len(cs.Learners) > 0 {
+		if len(peers) > 0 || len(learners) > 0 {
 			// TODO(bdarnell): the peers argument is always nil except in
 			// tests; the argument should be removed and these tests should be
 			// updated to specify their nodes through a snapshot.
-			panic("cannot specify both newRaft(peers) and ConfState.Nodes)")
+			panic("cannot specify both newRaft(peers, learners) and ConfState.(Nodes, Learners)")
 		}
 		peers = cs.Nodes
+		learners = cs.Learners
 	}
 	r := &raft{
-		id:               c.ID,
-		lead:             None,
-		raftLog:          raftlog,
-		maxMsgSize:       c.MaxSizePerMsg,
-		maxInflight:      c.MaxInflightMsgs,
-		prs:              make(map[uint64]*Progress),
-		electionTimeout:  c.ElectionTick,
-		heartbeatTimeout: c.HeartbeatTick,
-		logger:           c.Logger,
-		checkQuorum:      c.CheckQuorum,
-		preVote:          c.PreVote,
-		readOnly:         newReadOnly(c.ReadOnlyOption),
+		id:                        c.ID,
+		lead:                      None,
+		isLearner:                 false,
+		raftLog:                   raftlog,
+		maxMsgSize:                c.MaxSizePerMsg,
+		maxInflight:               c.MaxInflightMsgs,
+		prs:                       make(map[uint64]*Progress),
+		learnerPrs:                make(map[uint64]*Progress),
+		electionTimeout:           c.ElectionTick,
+		heartbeatTimeout:          c.HeartbeatTick,
+		logger:                    c.Logger,
+		checkQuorum:               c.CheckQuorum,
+		preVote:                   c.PreVote,
+		readOnly:                  newReadOnly(c.ReadOnlyOption),
+		disableProposalForwarding: c.DisableProposalForwarding,
 	}
 	for _, p := range peers {
 		r.prs[p] = &Progress{Next: 1, ins: newInflights(r.maxInflight)}
 	}
+	for _, p := range learners {
+		if _, ok := r.prs[p]; ok {
+			panic(fmt.Sprintf("node %x is in both learner and peer list", p))
+		}
+		r.learnerPrs[p] = &Progress{Next: 1, ins: newInflights(r.maxInflight), IsLearner: true}
+		if r.id == p {
+			r.isLearner = true
+		}
+	}
+
 	if !isHardStateEqual(hs, emptyState) {
 		r.loadState(hs)
 	}
@@ -332,10 +371,13 @@ func (r *raft) hardState() pb.HardState {
 func (r *raft) quorum() int { return len(r.prs)/2 + 1 }
 
 func (r *raft) nodes() []uint64 {
-	nodes := make([]uint64, 0, len(r.prs))
+	nodes := make([]uint64, 0, len(r.prs)+len(r.learnerPrs))
 	for id := range r.prs {
 		nodes = append(nodes, id)
 	}
+	for id := range r.learnerPrs {
+		nodes = append(nodes, id)
+	}
 	sort.Sort(uint64Slice(nodes))
 	return nodes
 }
@@ -343,10 +385,20 @@ func (r *raft) nodes() []uint64 {
 // send persists state to stable storage and then sends to its mailbox.
 func (r *raft) send(m pb.Message) {
 	m.From = r.id
-	if m.Type == pb.MsgVote || m.Type == pb.MsgPreVote {
+	if m.Type == pb.MsgVote || m.Type == pb.MsgVoteResp || m.Type == pb.MsgPreVote || m.Type == pb.MsgPreVoteResp {
 		if m.Term == 0 {
-			// PreVote RPCs are sent at a term other than our actual term, so the code
-			// that sends these messages is responsible for setting the term.
+			// All {pre-,}campaign messages need to have the term set when
+			// sending.
+			// - MsgVote: m.Term is the term the node is campaigning for,
+			//   non-zero as we increment the term when campaigning.
+			// - MsgVoteResp: m.Term is the new r.Term if the MsgVote was
+			//   granted, non-zero for the same reason MsgVote is
+			// - MsgPreVote: m.Term is the term the node will campaign,
+			//   non-zero as we use m.Term to indicate the next term we'll be
+			//   campaigning for
+			// - MsgPreVoteResp: m.Term is the term received in the original
+			//   MsgPreVote if the pre-vote was granted, non-zero for the
+			//   same reasons MsgPreVote is
 			panic(fmt.Sprintf("term should be set when sending %s", m.Type))
 		}
 	} else {
@@ -364,9 +416,17 @@ func (r *raft) send(m pb.Message) {
 	r.msgs = append(r.msgs, m)
 }
 
+func (r *raft) getProgress(id uint64) *Progress {
+	if pr, ok := r.prs[id]; ok {
+		return pr
+	}
+
+	return r.learnerPrs[id]
+}
+
 // sendAppend sends RPC, with entries to the given peer.
 func (r *raft) sendAppend(to uint64) {
-	pr := r.prs[to]
+	pr := r.getProgress(to)
 	if pr.IsPaused() {
 		return
 	}
@@ -431,7 +491,7 @@ func (r *raft) sendHeartbeat(to uint64, ctx []byte) {
 	// or it might not have all the committed entries.
 	// The leader MUST NOT forward the follower's commit to
 	// an unmatched index.
-	commit := min(r.prs[to].Match, r.raftLog.committed)
+	commit := min(r.getProgress(to).Match, r.raftLog.committed)
 	m := pb.Message{
 		To:      to,
 		Type:    pb.MsgHeartbeat,
@@ -442,15 +502,26 @@ func (r *raft) sendHeartbeat(to uint64, ctx []byte) {
 	r.send(m)
 }
 
+func (r *raft) forEachProgress(f func(id uint64, pr *Progress)) {
+	for id, pr := range r.prs {
+		f(id, pr)
+	}
+
+	for id, pr := range r.learnerPrs {
+		f(id, pr)
+	}
+}
+
 // bcastAppend sends RPC, with entries to all peers that are not up-to-date
 // according to the progress recorded in r.prs.
 func (r *raft) bcastAppend() {
-	for id := range r.prs {
+	r.forEachProgress(func(id uint64, _ *Progress) {
 		if id == r.id {
-			continue
+			return
 		}
+
 		r.sendAppend(id)
-	}
+	})
 }
 
 // bcastHeartbeat sends RPC, without entries to all the peers.
@@ -464,12 +535,12 @@ func (r *raft) bcastHeartbeat() {
 }
 
 func (r *raft) bcastHeartbeatWithCtx(ctx []byte) {
-	for id := range r.prs {
+	r.forEachProgress(func(id uint64, _ *Progress) {
 		if id == r.id {
-			continue
+			return
 		}
 		r.sendHeartbeat(id, ctx)
-	}
+	})
 }
 
 // maybeCommit attempts to advance the commit index. Returns true if
@@ -478,8 +549,8 @@ func (r *raft) bcastHeartbeatWithCtx(ctx []byte) {
 func (r *raft) maybeCommit() bool {
 	// TODO(bmizerany): optimize.. Currently naive
 	mis := make(uint64Slice, 0, len(r.prs))
-	for id := range r.prs {
-		mis = append(mis, r.prs[id].Match)
+	for _, p := range r.prs {
+		mis = append(mis, p.Match)
 	}
 	sort.Sort(sort.Reverse(mis))
 	mci := mis[r.quorum()-1]
@@ -500,12 +571,13 @@ func (r *raft) reset(term uint64) {
 	r.abortLeaderTransfer()
 
 	r.votes = make(map[uint64]bool)
-	for id := range r.prs {
-		r.prs[id] = &Progress{Next: r.raftLog.lastIndex() + 1, ins: newInflights(r.maxInflight)}
+	r.forEachProgress(func(id uint64, pr *Progress) {
+		*pr = Progress{Next: r.raftLog.lastIndex() + 1, ins: newInflights(r.maxInflight), IsLearner: pr.IsLearner}
 		if id == r.id {
-			r.prs[id].Match = r.raftLog.lastIndex()
+			pr.Match = r.raftLog.lastIndex()
 		}
-	}
+	})
+
 	r.pendingConf = false
 	r.readOnly = newReadOnly(r.readOnly.option)
 }
@@ -517,7 +589,7 @@ func (r *raft) appendEntry(es ...pb.Entry) {
 		es[i].Index = li + 1 + uint64(i)
 	}
 	r.raftLog.append(es...)
-	r.prs[r.id].maybeUpdate(r.raftLog.lastIndex())
+	r.getProgress(r.id).maybeUpdate(r.raftLog.lastIndex())
 	// Regardless of maybeCommit's return, our caller will call bcastAppend.
 	r.maybeCommit()
 }
@@ -589,6 +661,7 @@ func (r *raft) becomePreCandidate() {
 	// but doesn't change anything else. In particular it does not increase
 	// r.Term or change r.Vote.
 	r.step = stepCandidate
+	r.votes = make(map[uint64]bool)
 	r.tick = r.tickElection
 	r.state = StatePreCandidate
 	r.logger.Infof("%x became pre-candidate at term %d", r.id, r.Term)
@@ -682,7 +755,6 @@ func (r *raft) Step(m pb.Message) error {
 	case m.Term == 0:
 		// local message
 	case m.Term > r.Term:
-		lead := m.From
 		if m.Type == pb.MsgVote || m.Type == pb.MsgPreVote {
 			force := bytes.Equal(m.Context, []byte(campaignTransfer))
 			inLease := r.checkQuorum && r.lead != None && r.electionElapsed < r.electionTimeout
@@ -693,7 +765,6 @@ func (r *raft) Step(m pb.Message) error {
 					r.id, r.raftLog.lastTerm(), r.raftLog.lastIndex(), r.Vote, m.Type, m.From, m.LogTerm, m.Index, r.Term, r.electionTimeout-r.electionElapsed)
 				return nil
 			}
-			lead = None
 		}
 		switch {
 		case m.Type == pb.MsgPreVote:
@@ -707,7 +778,11 @@ func (r *raft) Step(m pb.Message) error {
 		default:
 			r.logger.Infof("%x [term: %d] received a %s message with higher term from %x [term: %d]",
 				r.id, r.Term, m.Type, m.From, m.Term)
-			r.becomeFollower(m.Term, lead)
+			if m.Type == pb.MsgApp || m.Type == pb.MsgHeartbeat || m.Type == pb.MsgSnap {
+				r.becomeFollower(m.Term, m.From)
+			} else {
+				r.becomeFollower(m.Term, None)
+			}
 		}
 
 	case m.Term < r.Term:
@@ -757,12 +832,27 @@ func (r *raft) Step(m pb.Message) error {
 		}
 
 	case pb.MsgVote, pb.MsgPreVote:
+		if r.isLearner {
+			// TODO: learner may need to vote, in case of node down when confchange.
+			r.logger.Infof("%x [logterm: %d, index: %d, vote: %x] ignored %s from %x [logterm: %d, index: %d] at term %d: learner can not vote",
+				r.id, r.raftLog.lastTerm(), r.raftLog.lastIndex(), r.Vote, m.Type, m.From, m.LogTerm, m.Index, r.Term)
+			return nil
+		}
 		// The m.Term > r.Term clause is for MsgPreVote. For MsgVote m.Term should
 		// always equal r.Term.
 		if (r.Vote == None || m.Term > r.Term || r.Vote == m.From) && r.raftLog.isUpToDate(m.Index, m.LogTerm) {
 			r.logger.Infof("%x [logterm: %d, index: %d, vote: %x] cast %s for %x [logterm: %d, index: %d] at term %d",
 				r.id, r.raftLog.lastTerm(), r.raftLog.lastIndex(), r.Vote, m.Type, m.From, m.LogTerm, m.Index, r.Term)
-			r.send(pb.Message{To: m.From, Type: voteRespMsgType(m.Type)})
+			// When responding to Msg{Pre,}Vote messages we include the term
+			// from the message, not the local term. To see why consider the
+			// case where a single node was previously partitioned away and
+			// it's local term is now of date. If we include the local term
+			// (recall that for pre-votes we don't update the local term), the
+			// (pre-)campaigning node on the other end will proceed to ignore
+			// the message (it ignores all out of date messages).
+			// The term in the original message and current local term are the
+			// same in the case of regular votes, but different for pre-votes.
+			r.send(pb.Message{To: m.From, Term: m.Term, Type: voteRespMsgType(m.Type)})
 			if m.Type == pb.MsgVote {
 				// Only record real votes.
 				r.electionElapsed = 0
@@ -771,7 +861,7 @@ func (r *raft) Step(m pb.Message) error {
 		} else {
 			r.logger.Infof("%x [logterm: %d, index: %d, vote: %x] rejected %s from %x [logterm: %d, index: %d] at term %d",
 				r.id, r.raftLog.lastTerm(), r.raftLog.lastIndex(), r.Vote, m.Type, m.From, m.LogTerm, m.Index, r.Term)
-			r.send(pb.Message{To: m.From, Type: voteRespMsgType(m.Type), Reject: true})
+			r.send(pb.Message{To: m.From, Term: r.Term, Type: voteRespMsgType(m.Type), Reject: true})
 		}
 
 	default:
@@ -836,10 +926,7 @@ func stepLeader(r *raft, m pb.Message) {
 				r.readOnly.addRequest(r.raftLog.committed, m)
 				r.bcastHeartbeatWithCtx(m.Entries[0].Data)
 			case ReadOnlyLeaseBased:
-				var ri uint64
-				if r.checkQuorum {
-					ri = r.raftLog.committed
-				}
+				ri := r.raftLog.committed
 				if m.From == None || m.From == r.id { // from local member
 					r.readStates = append(r.readStates, ReadState{Index: r.raftLog.committed, RequestCtx: m.Entries[0].Data})
 				} else {
@@ -854,8 +941,8 @@ func stepLeader(r *raft, m pb.Message) {
 	}
 
 	// All other message types require a progress for m.From (pr).
-	pr, prOk := r.prs[m.From]
-	if !prOk {
+	pr := r.getProgress(m.From)
+	if pr == nil {
 		r.logger.Debugf("%x no progress available for %x", r.id, m.From)
 		return
 	}
@@ -954,6 +1041,10 @@ func stepLeader(r *raft, m pb.Message) {
 		}
 		r.logger.Debugf("%x failed to send message to %x because it is unreachable [%s]", r.id, m.From, pr)
 	case pb.MsgTransferLeader:
+		if pr.IsLearner {
+			r.logger.Debugf("%x is learner. Ignored transferring leadership", r.id)
+			return
+		}
 		leadTransferee := m.From
 		lastLeadTransferee := r.leadTransferee
 		if lastLeadTransferee != None {
@@ -1033,6 +1124,9 @@ func stepFollower(r *raft, m pb.Message) {
 		if r.lead == None {
 			r.logger.Infof("%x no leader at term %d; dropping proposal", r.id, r.Term)
 			return
+		} else if r.disableProposalForwarding {
+			r.logger.Infof("%x not forwarding to leader %x at term %d; dropping proposal", r.id, r.lead, r.Term)
+			return
 		}
 		m.To = r.lead
 		r.send(m)
@@ -1127,20 +1221,37 @@ func (r *raft) restore(s pb.Snapshot) bool {
 		return false
 	}
 
+	// The normal peer can't become learner.
+	if !r.isLearner {
+		for _, id := range s.Metadata.ConfState.Learners {
+			if id == r.id {
+				r.logger.Errorf("%x can't become learner when restores snapshot [index: %d, term: %d]", r.id, s.Metadata.Index, s.Metadata.Term)
+				return false
+			}
+		}
+	}
+
 	r.logger.Infof("%x [commit: %d, lastindex: %d, lastterm: %d] starts to restore snapshot [index: %d, term: %d]",
 		r.id, r.raftLog.committed, r.raftLog.lastIndex(), r.raftLog.lastTerm(), s.Metadata.Index, s.Metadata.Term)
 
 	r.raftLog.restore(s)
 	r.prs = make(map[uint64]*Progress)
-	for _, n := range s.Metadata.ConfState.Nodes {
+	r.learnerPrs = make(map[uint64]*Progress)
+	r.restoreNode(s.Metadata.ConfState.Nodes, false)
+	r.restoreNode(s.Metadata.ConfState.Learners, true)
+	return true
+}
+
+func (r *raft) restoreNode(nodes []uint64, isLearner bool) {
+	for _, n := range nodes {
 		match, next := uint64(0), r.raftLog.lastIndex()+1
 		if n == r.id {
 			match = next - 1
+			r.isLearner = isLearner
 		}
-		r.setProgress(n, match, next)
-		r.logger.Infof("%x restored progress of %x [%s]", r.id, n, r.prs[n])
+		r.setProgress(n, match, next, isLearner)
+		r.logger.Infof("%x restored progress of %x [%s]", r.id, n, r.getProgress(n))
 	}
-	return true
 }
 
 // promotable indicates whether state machine can be promoted to leader,
@@ -1151,18 +1262,46 @@ func (r *raft) promotable() bool {
 }
 
 func (r *raft) addNode(id uint64) {
+	r.addNodeOrLearnerNode(id, false)
+}
+
+func (r *raft) addLearner(id uint64) {
+	r.addNodeOrLearnerNode(id, true)
+}
+
+func (r *raft) addNodeOrLearnerNode(id uint64, isLearner bool) {
 	r.pendingConf = false
-	if _, ok := r.prs[id]; ok {
-		// Ignore any redundant addNode calls (which can happen because the
-		// initial bootstrapping entries are applied twice).
-		return
+	pr := r.getProgress(id)
+	if pr == nil {
+		r.setProgress(id, 0, r.raftLog.lastIndex()+1, isLearner)
+	} else {
+		if isLearner && !pr.IsLearner {
+			// can only change Learner to Voter
+			r.logger.Infof("%x ignored addLeaner: do not support changing %x from raft peer to learner.", r.id, id)
+			return
+		}
+
+		if isLearner == pr.IsLearner {
+			// Ignore any redundant addNode calls (which can happen because the
+			// initial bootstrapping entries are applied twice).
+			return
+		}
+
+		// change Learner to Voter, use origin Learner progress
+		delete(r.learnerPrs, id)
+		pr.IsLearner = false
+		r.prs[id] = pr
+	}
+
+	if r.id == id {
+		r.isLearner = isLearner
 	}
 
-	r.setProgress(id, 0, r.raftLog.lastIndex()+1)
 	// When a node is first added, we should mark it as recently active.
 	// Otherwise, CheckQuorum may cause us to step down if it is invoked
 	// before the added node has a chance to communicate with us.
-	r.prs[id].RecentActive = true
+	pr = r.getProgress(id)
+	pr.RecentActive = true
 }
 
 func (r *raft) removeNode(id uint64) {
@@ -1170,7 +1309,7 @@ func (r *raft) removeNode(id uint64) {
 	r.pendingConf = false
 
 	// do not try to commit or abort transferring if there is no nodes in the cluster.
-	if len(r.prs) == 0 {
+	if len(r.prs) == 0 && len(r.learnerPrs) == 0 {
 		return
 	}
 
@@ -1187,12 +1326,22 @@ func (r *raft) removeNode(id uint64) {
 
 func (r *raft) resetPendingConf() { r.pendingConf = false }
 
-func (r *raft) setProgress(id, match, next uint64) {
-	r.prs[id] = &Progress{Next: next, Match: match, ins: newInflights(r.maxInflight)}
+func (r *raft) setProgress(id, match, next uint64, isLearner bool) {
+	if !isLearner {
+		delete(r.learnerPrs, id)
+		r.prs[id] = &Progress{Next: next, Match: match, ins: newInflights(r.maxInflight)}
+		return
+	}
+
+	if _, ok := r.prs[id]; ok {
+		panic(fmt.Sprintf("%x unexpected changing from voter to learner for %x", r.id, id))
+	}
+	r.learnerPrs[id] = &Progress{Next: next, Match: match, ins: newInflights(r.maxInflight), IsLearner: true}
 }
 
 func (r *raft) delProgress(id uint64) {
 	delete(r.prs, id)
+	delete(r.learnerPrs, id)
 }
 
 func (r *raft) loadState(state pb.HardState) {
@@ -1222,18 +1371,18 @@ func (r *raft) resetRandomizedElectionTimeout() {
 func (r *raft) checkQuorumActive() bool {
 	var act int
 
-	for id := range r.prs {
+	r.forEachProgress(func(id uint64, pr *Progress) {
 		if id == r.id { // self is always active
 			act++
-			continue
+			return
 		}
 
-		if r.prs[id].RecentActive {
+		if pr.RecentActive && !pr.IsLearner {
 			act++
 		}
 
-		r.prs[id].RecentActive = false
-	}
+		pr.RecentActive = false
+	})
 
 	return act >= r.quorum()
 }
diff --git a/vendor/github.com/coreos/etcd/raft/raftpb/BUILD b/vendor/github.com/coreos/etcd/raft/raftpb/BUILD
index bbf500afda4..03e6b523c3c 100644
--- a/vendor/github.com/coreos/etcd/raft/raftpb/BUILD
+++ b/vendor/github.com/coreos/etcd/raft/raftpb/BUILD
@@ -6,7 +6,10 @@ go_library(
     importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/raft/raftpb",
     importpath = "github.com/coreos/etcd/raft/raftpb",
     visibility = ["//visibility:public"],
-    deps = ["//vendor/github.com/golang/protobuf/proto:go_default_library"],
+    deps = [
+        "//vendor/github.com/gogo/protobuf/gogoproto:go_default_library",
+        "//vendor/github.com/golang/protobuf/proto:go_default_library",
+    ],
 )
 
 filegroup(
diff --git a/vendor/github.com/coreos/etcd/raft/raftpb/raft.pb.go b/vendor/github.com/coreos/etcd/raft/raftpb/raft.pb.go
index 4c6e79d58a0..fd9ee3729ec 100644
--- a/vendor/github.com/coreos/etcd/raft/raftpb/raft.pb.go
+++ b/vendor/github.com/coreos/etcd/raft/raftpb/raft.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: raft.proto
-// DO NOT EDIT!
 
 /*
 	Package raftpb is a generated protocol buffer package.
@@ -26,6 +25,8 @@ import (
 
 	math "math"
 
+	_ "github.com/gogo/protobuf/gogoproto"
+
 	io "io"
 )
 
@@ -162,20 +163,23 @@ func (MessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaft,
 type ConfChangeType int32
 
 const (
-	ConfChangeAddNode    ConfChangeType = 0
-	ConfChangeRemoveNode ConfChangeType = 1
-	ConfChangeUpdateNode ConfChangeType = 2
+	ConfChangeAddNode        ConfChangeType = 0
+	ConfChangeRemoveNode     ConfChangeType = 1
+	ConfChangeUpdateNode     ConfChangeType = 2
+	ConfChangeAddLearnerNode ConfChangeType = 3
 )
 
 var ConfChangeType_name = map[int32]string{
 	0: "ConfChangeAddNode",
 	1: "ConfChangeRemoveNode",
 	2: "ConfChangeUpdateNode",
+	3: "ConfChangeAddLearnerNode",
 }
 var ConfChangeType_value = map[string]int32{
-	"ConfChangeAddNode":    0,
-	"ConfChangeRemoveNode": 1,
-	"ConfChangeUpdateNode": 2,
+	"ConfChangeAddNode":        0,
+	"ConfChangeRemoveNode":     1,
+	"ConfChangeUpdateNode":     2,
+	"ConfChangeAddLearnerNode": 3,
 }
 
 func (x ConfChangeType) Enum() *ConfChangeType {
@@ -267,6 +271,7 @@ func (*HardState) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []in
 
 type ConfState struct {
 	Nodes            []uint64 `protobuf:"varint,1,rep,name=nodes" json:"nodes,omitempty"`
+	Learners         []uint64 `protobuf:"varint,2,rep,name=learners" json:"learners,omitempty"`
 	XXX_unrecognized []byte   `json:"-"`
 }
 
@@ -537,6 +542,13 @@ func (m *ConfState) MarshalTo(dAtA []byte) (int, error) {
 			i = encodeVarintRaft(dAtA, i, uint64(num))
 		}
 	}
+	if len(m.Learners) > 0 {
+		for _, num := range m.Learners {
+			dAtA[i] = 0x10
+			i++
+			i = encodeVarintRaft(dAtA, i, uint64(num))
+		}
+	}
 	if m.XXX_unrecognized != nil {
 		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
@@ -579,24 +591,6 @@ func (m *ConfChange) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Raft(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Raft(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintRaft(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -700,6 +694,11 @@ func (m *ConfState) Size() (n int) {
 			n += 1 + sovRaft(uint64(e))
 		}
 	}
+	if len(m.Learners) > 0 {
+		for _, e := range m.Learners {
+			n += 1 + sovRaft(uint64(e))
+		}
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -1619,6 +1618,68 @@ func (m *ConfState) Unmarshal(dAtA []byte) error {
 			} else {
 				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
 			}
+		case 2:
+			if wireType == 0 {
+				var v uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowRaft
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.Learners = append(m.Learners, v)
+			} else if wireType == 2 {
+				var packedLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowRaft
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					packedLen |= (int(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if packedLen < 0 {
+					return ErrInvalidLengthRaft
+				}
+				postIndex := iNdEx + packedLen
+				if postIndex > l {
+					return io.ErrUnexpectedEOF
+				}
+				for iNdEx < postIndex {
+					var v uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowRaft
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					m.Learners = append(m.Learners, v)
+				}
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field Learners", wireType)
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipRaft(dAtA[iNdEx:])
@@ -1888,55 +1949,56 @@ var (
 func init() { proto.RegisterFile("raft.proto", fileDescriptorRaft) }
 
 var fileDescriptorRaft = []byte{
-	// 790 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x54, 0xcd, 0x6e, 0xdb, 0x46,
-	0x10, 0x16, 0x29, 0xea, 0x6f, 0x28, 0xcb, 0xab, 0xb5, 0x5a, 0x2c, 0x0c, 0x43, 0x55, 0x85, 0x1e,
-	0x04, 0x17, 0x76, 0x5b, 0x1d, 0x7a, 0xe8, 0xcd, 0x96, 0x0a, 0x58, 0x40, 0x65, 0xb8, 0xb2, 0xdc,
-	0x43, 0x83, 0x20, 0x58, 0x8b, 0x2b, 0x4a, 0x89, 0xc9, 0x25, 0x96, 0x2b, 0xc7, 0xbe, 0x04, 0x79,
-	0x80, 0x3c, 0x40, 0x2e, 0x79, 0x1f, 0x1f, 0x0d, 0xe4, 0x1e, 0xc4, 0xce, 0x8b, 0x04, 0xbb, 0x5c,
-	0x4a, 0x94, 0x74, 0xdb, 0xf9, 0xbe, 0xe1, 0xcc, 0x37, 0xdf, 0xce, 0x12, 0x40, 0xd0, 0xa9, 0x3c,
-	0x8e, 0x04, 0x97, 0x1c, 0x17, 0xd5, 0x39, 0xba, 0xde, 0x6f, 0xf8, 0xdc, 0xe7, 0x1a, 0xfa, 0x4d,
-	0x9d, 0x12, 0xb6, 0xfd, 0x0e, 0x0a, 0x7f, 0x87, 0x52, 0xdc, 0xe3, 0x5f, 0xc1, 0x19, 0xdf, 0x47,
-	0x8c, 0x58, 0x2d, 0xab, 0x53, 0xeb, 0xd6, 0x8f, 0x93, 0xaf, 0x8e, 0x35, 0xa9, 0x88, 0x53, 0xe7,
-	0xe1, 0xcb, 0x4f, 0xb9, 0x91, 0x4e, 0xc2, 0x04, 0x9c, 0x31, 0x13, 0x01, 0xb1, 0x5b, 0x56, 0xc7,
-	0x59, 0x32, 0x4c, 0x04, 0x78, 0x1f, 0x0a, 0x83, 0xd0, 0x63, 0x77, 0x24, 0x9f, 0xa1, 0x12, 0x08,
-	0x63, 0x70, 0xfa, 0x54, 0x52, 0xe2, 0xb4, 0xac, 0x4e, 0x75, 0xa4, 0xcf, 0xed, 0xf7, 0x16, 0xa0,
-	0xcb, 0x90, 0x46, 0xf1, 0x8c, 0xcb, 0x21, 0x93, 0xd4, 0xa3, 0x92, 0xe2, 0x3f, 0x01, 0x26, 0x3c,
-	0x9c, 0xbe, 0x8a, 0x25, 0x95, 0x89, 0x22, 0x77, 0xa5, 0xa8, 0xc7, 0xc3, 0xe9, 0xa5, 0x22, 0x4c,
-	0xf1, 0xca, 0x24, 0x05, 0x54, 0xf3, 0xb9, 0x6e, 0x9e, 0xd5, 0x95, 0x40, 0x4a, 0xb2, 0x54, 0x92,
-	0xb3, 0xba, 0x34, 0xd2, 0xfe, 0x1f, 0xca, 0xa9, 0x02, 0x25, 0x51, 0x29, 0xd0, 0x3d, 0xab, 0x23,
-	0x7d, 0xc6, 0x7f, 0x41, 0x39, 0x30, 0xca, 0x74, 0x61, 0xb7, 0x4b, 0x52, 0x2d, 0x9b, 0xca, 0x4d,
-	0xdd, 0x65, 0x7e, 0xfb, 0x53, 0x1e, 0x4a, 0x43, 0x16, 0xc7, 0xd4, 0x67, 0xf8, 0x08, 0x1c, 0xb9,
-	0x72, 0x78, 0x2f, 0xad, 0x61, 0xe8, 0xac, 0xc7, 0x2a, 0x0d, 0x37, 0xc0, 0x96, 0x7c, 0x6d, 0x12,
-	0x5b, 0x72, 0x35, 0xc6, 0x54, 0xf0, 0x8d, 0x31, 0x14, 0xb2, 0x1c, 0xd0, 0xd9, 0x1c, 0x10, 0x37,
-	0xa1, 0x74, 0xc3, 0x7d, 0x7d, 0x61, 0x85, 0x0c, 0x99, 0x82, 0x2b, 0xdb, 0x8a, 0xdb, 0xb6, 0x1d,
-	0x41, 0x89, 0x85, 0x52, 0xcc, 0x59, 0x4c, 0x4a, 0xad, 0x7c, 0xc7, 0xed, 0xee, 0xac, 0x6d, 0x46,
-	0x5a, 0xca, 0xe4, 0xe0, 0x03, 0x28, 0x4e, 0x78, 0x10, 0xcc, 0x25, 0x29, 0x67, 0x6a, 0x19, 0x0c,
-	0x77, 0xa1, 0x1c, 0x1b, 0xc7, 0x48, 0x45, 0x3b, 0x89, 0x36, 0x9d, 0x4c, 0x1d, 0x4c, 0xf3, 0x54,
-	0x45, 0xc1, 0x5e, 0xb3, 0x89, 0x24, 0xd0, 0xb2, 0x3a, 0xe5, 0xb4, 0x62, 0x82, 0xe1, 0x5f, 0x00,
-	0x92, 0xd3, 0xd9, 0x3c, 0x94, 0xc4, 0xcd, 0xf4, 0xcc, 0xe0, 0x98, 0x40, 0x69, 0xc2, 0x43, 0xc9,
-	0xee, 0x24, 0xa9, 0xea, 0x8b, 0x4d, 0xc3, 0xf6, 0x4b, 0xa8, 0x9c, 0x51, 0xe1, 0x25, 0xeb, 0x93,
-	0x3a, 0x68, 0x6d, 0x39, 0x48, 0xc0, 0xb9, 0xe5, 0x92, 0xad, 0xef, 0xbb, 0x42, 0x32, 0x03, 0xe7,
-	0xb7, 0x07, 0x6e, 0xff, 0x0c, 0x95, 0xe5, 0xba, 0xe2, 0x06, 0x14, 0x42, 0xee, 0xb1, 0x98, 0x58,
-	0xad, 0x7c, 0xc7, 0x19, 0x25, 0x41, 0xfb, 0x83, 0x05, 0xa0, 0x72, 0x7a, 0x33, 0x1a, 0xfa, 0xfa,
-	0xd6, 0x07, 0xfd, 0x35, 0x05, 0xf6, 0xa0, 0x8f, 0x7f, 0x37, 0x8f, 0xd3, 0xd6, 0xab, 0xf3, 0x63,
-	0xf6, 0x29, 0x24, 0xdf, 0x6d, 0xbd, 0xd0, 0x03, 0x28, 0x9e, 0x73, 0x8f, 0x0d, 0xfa, 0xeb, 0xba,
-	0x12, 0x4c, 0x19, 0xd2, 0x33, 0x86, 0x24, 0x8f, 0x31, 0x0d, 0x0f, 0xff, 0x80, 0xca, 0xf2, 0xc9,
-	0xe3, 0x5d, 0x70, 0x75, 0x70, 0xce, 0x45, 0x40, 0x6f, 0x50, 0x0e, 0xef, 0xc1, 0xae, 0x06, 0x56,
-	0x8d, 0x91, 0x75, 0xf8, 0xd9, 0x06, 0x37, 0xb3, 0xc4, 0x18, 0xa0, 0x38, 0x8c, 0xfd, 0xb3, 0x45,
-	0x84, 0x72, 0xd8, 0x85, 0xd2, 0x30, 0xf6, 0x4f, 0x19, 0x95, 0xc8, 0x32, 0xc1, 0x85, 0xe0, 0x11,
-	0xb2, 0x4d, 0xd6, 0x49, 0x14, 0xa1, 0x3c, 0xae, 0x01, 0x24, 0xe7, 0x11, 0x8b, 0x23, 0xe4, 0x98,
-	0xc4, 0xff, 0xb8, 0x64, 0xa8, 0xa0, 0x44, 0x98, 0x40, 0xb3, 0x45, 0xc3, 0xaa, 0x85, 0x41, 0x25,
-	0x8c, 0xa0, 0xaa, 0x9a, 0x31, 0x2a, 0xe4, 0xb5, 0xea, 0x52, 0xc6, 0x0d, 0x40, 0x59, 0x44, 0x7f,
-	0x54, 0xc1, 0x18, 0x6a, 0xc3, 0xd8, 0xbf, 0x0a, 0x05, 0xa3, 0x93, 0x19, 0xbd, 0xbe, 0x61, 0x08,
-	0x70, 0x1d, 0x76, 0x4c, 0x21, 0x75, 0x41, 0x8b, 0x18, 0xb9, 0x26, 0xad, 0x37, 0x63, 0x93, 0x37,
-	0xff, 0x2e, 0xb8, 0x58, 0x04, 0xa8, 0x8a, 0x7f, 0x80, 0xfa, 0x30, 0xf6, 0xc7, 0x82, 0x86, 0xf1,
-	0x94, 0x89, 0x7f, 0x18, 0xf5, 0x98, 0x40, 0x3b, 0xe6, 0xeb, 0xf1, 0x3c, 0x60, 0x7c, 0x21, 0xcf,
-	0xf9, 0x5b, 0x54, 0x33, 0x62, 0x46, 0x8c, 0x7a, 0xfa, 0x87, 0x87, 0x76, 0x8d, 0x98, 0x25, 0xa2,
-	0xc5, 0x20, 0x33, 0xef, 0x85, 0x60, 0x7a, 0xc4, 0xba, 0xe9, 0x6a, 0x62, 0x9d, 0x83, 0x0f, 0x5f,
-	0x40, 0x6d, 0xfd, 0x7a, 0x95, 0x8e, 0x15, 0x72, 0xe2, 0x79, 0xea, 0x2e, 0x51, 0x0e, 0x13, 0x68,
-	0xac, 0xe0, 0x11, 0x0b, 0xf8, 0x2d, 0xd3, 0x8c, 0xb5, 0xce, 0x5c, 0x45, 0x1e, 0x95, 0x09, 0x63,
-	0x9f, 0x92, 0x87, 0xa7, 0x66, 0xee, 0xf1, 0xa9, 0x99, 0x7b, 0x78, 0x6e, 0x5a, 0x8f, 0xcf, 0x4d,
-	0xeb, 0xeb, 0x73, 0xd3, 0xfa, 0xf8, 0xad, 0x99, 0xfb, 0x1e, 0x00, 0x00, 0xff, 0xff, 0xcf, 0x30,
-	0x01, 0x41, 0x3a, 0x06, 0x00, 0x00,
+	// 815 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x54, 0xcd, 0x6e, 0x23, 0x45,
+	0x10, 0xf6, 0x8c, 0xc7, 0x7f, 0x35, 0x8e, 0xd3, 0xa9, 0x35, 0xa8, 0x15, 0x45, 0xc6, 0xb2, 0x38,
+	0x58, 0x41, 0x1b, 0x20, 0x07, 0x0e, 0x48, 0x1c, 0x36, 0x09, 0x52, 0x22, 0xad, 0xa3, 0xc5, 0x9b,
+	0xe5, 0x80, 0x84, 0x50, 0xc7, 0x53, 0x9e, 0x18, 0x32, 0xd3, 0xa3, 0x9e, 0xf6, 0xb2, 0xb9, 0x20,
+	0x1e, 0x80, 0x07, 0xe0, 0xc2, 0xfb, 0xe4, 0xb8, 0x12, 0x77, 0xc4, 0x86, 0x17, 0x41, 0xdd, 0xd3,
+	0x63, 0xcf, 0x24, 0xb7, 0xae, 0xef, 0xab, 0xae, 0xfa, 0xea, 0xeb, 0x9a, 0x01, 0x50, 0x62, 0xa9,
+	0x8f, 0x32, 0x25, 0xb5, 0xc4, 0xb6, 0x39, 0x67, 0xd7, 0xfb, 0xc3, 0x58, 0xc6, 0xd2, 0x42, 0x9f,
+	0x9b, 0x53, 0xc1, 0x4e, 0x7e, 0x83, 0xd6, 0xb7, 0xa9, 0x56, 0x77, 0xf8, 0x19, 0x04, 0x57, 0x77,
+	0x19, 0x71, 0x6f, 0xec, 0x4d, 0x07, 0xc7, 0x7b, 0x47, 0xc5, 0xad, 0x23, 0x4b, 0x1a, 0xe2, 0x24,
+	0xb8, 0xff, 0xe7, 0x93, 0xc6, 0xdc, 0x26, 0x21, 0x87, 0xe0, 0x8a, 0x54, 0xc2, 0xfd, 0xb1, 0x37,
+	0x0d, 0x36, 0x0c, 0xa9, 0x04, 0xf7, 0xa1, 0x75, 0x91, 0x46, 0xf4, 0x8e, 0x37, 0x2b, 0x54, 0x01,
+	0x21, 0x42, 0x70, 0x26, 0xb4, 0xe0, 0xc1, 0xd8, 0x9b, 0xf6, 0xe7, 0xf6, 0x3c, 0xf9, 0xdd, 0x03,
+	0xf6, 0x3a, 0x15, 0x59, 0x7e, 0x23, 0xf5, 0x8c, 0xb4, 0x88, 0x84, 0x16, 0xf8, 0x15, 0xc0, 0x42,
+	0xa6, 0xcb, 0x9f, 0x72, 0x2d, 0x74, 0xa1, 0x28, 0xdc, 0x2a, 0x3a, 0x95, 0xe9, 0xf2, 0xb5, 0x21,
+	0x5c, 0xf1, 0xde, 0xa2, 0x04, 0x4c, 0xf3, 0x95, 0x6d, 0x5e, 0xd5, 0x55, 0x40, 0x46, 0xb2, 0x36,
+	0x92, 0xab, 0xba, 0x2c, 0x32, 0xf9, 0x01, 0xba, 0xa5, 0x02, 0x23, 0xd1, 0x28, 0xb0, 0x3d, 0xfb,
+	0x73, 0x7b, 0xc6, 0xaf, 0xa1, 0x9b, 0x38, 0x65, 0xb6, 0x70, 0x78, 0xcc, 0x4b, 0x2d, 0x8f, 0x95,
+	0xbb, 0xba, 0x9b, 0xfc, 0xc9, 0x5f, 0x4d, 0xe8, 0xcc, 0x28, 0xcf, 0x45, 0x4c, 0xf8, 0x1c, 0x02,
+	0xbd, 0x75, 0xf8, 0x59, 0x59, 0xc3, 0xd1, 0x55, 0x8f, 0x4d, 0x1a, 0x0e, 0xc1, 0xd7, 0xb2, 0x36,
+	0x89, 0xaf, 0xa5, 0x19, 0x63, 0xa9, 0xe4, 0xa3, 0x31, 0x0c, 0xb2, 0x19, 0x30, 0x78, 0x3c, 0x20,
+	0x8e, 0xa0, 0x73, 0x2b, 0x63, 0xfb, 0x60, 0xad, 0x0a, 0x59, 0x82, 0x5b, 0xdb, 0xda, 0x4f, 0x6d,
+	0x7b, 0x0e, 0x1d, 0x4a, 0xb5, 0x5a, 0x51, 0xce, 0x3b, 0xe3, 0xe6, 0x34, 0x3c, 0xde, 0xa9, 0x6d,
+	0x46, 0x59, 0xca, 0xe5, 0xe0, 0x01, 0xb4, 0x17, 0x32, 0x49, 0x56, 0x9a, 0x77, 0x2b, 0xb5, 0x1c,
+	0x86, 0xc7, 0xd0, 0xcd, 0x9d, 0x63, 0xbc, 0x67, 0x9d, 0x64, 0x8f, 0x9d, 0x2c, 0x1d, 0x2c, 0xf3,
+	0x4c, 0x45, 0x45, 0x3f, 0xd3, 0x42, 0x73, 0x18, 0x7b, 0xd3, 0x6e, 0x59, 0xb1, 0xc0, 0xf0, 0x53,
+	0x80, 0xe2, 0x74, 0xbe, 0x4a, 0x35, 0x0f, 0x2b, 0x3d, 0x2b, 0x38, 0x72, 0xe8, 0x2c, 0x64, 0xaa,
+	0xe9, 0x9d, 0xe6, 0x7d, 0xfb, 0xb0, 0x65, 0x38, 0xf9, 0x11, 0x7a, 0xe7, 0x42, 0x45, 0xc5, 0xfa,
+	0x94, 0x0e, 0x7a, 0x4f, 0x1c, 0xe4, 0x10, 0xbc, 0x95, 0x9a, 0xea, 0xfb, 0x6e, 0x90, 0xca, 0xc0,
+	0xcd, 0xa7, 0x03, 0x4f, 0xbe, 0x81, 0xde, 0x66, 0x5d, 0x71, 0x08, 0xad, 0x54, 0x46, 0x94, 0x73,
+	0x6f, 0xdc, 0x9c, 0x06, 0xf3, 0x22, 0xc0, 0x7d, 0xe8, 0xde, 0x92, 0x50, 0x29, 0xa9, 0x9c, 0xfb,
+	0x96, 0xd8, 0xc4, 0x93, 0x3f, 0x3c, 0x00, 0x73, 0xff, 0xf4, 0x46, 0xa4, 0xb1, 0xdd, 0x88, 0x8b,
+	0xb3, 0x9a, 0x3a, 0xff, 0xe2, 0x0c, 0xbf, 0x70, 0x1f, 0xae, 0x6f, 0xd7, 0xea, 0xe3, 0xea, 0x67,
+	0x52, 0xdc, 0x7b, 0xf2, 0xf5, 0x1e, 0x40, 0xfb, 0x52, 0x46, 0x74, 0x71, 0x56, 0xd7, 0x5c, 0x60,
+	0xc6, 0xac, 0x53, 0x67, 0x56, 0xf1, 0xa1, 0x96, 0xe1, 0xe1, 0x97, 0xd0, 0xdb, 0xfc, 0x0e, 0x70,
+	0x17, 0x42, 0x1b, 0x5c, 0x4a, 0x95, 0x88, 0x5b, 0xd6, 0xc0, 0x67, 0xb0, 0x6b, 0x81, 0x6d, 0x63,
+	0xe6, 0x1d, 0xfe, 0xed, 0x43, 0x58, 0x59, 0x70, 0x04, 0x68, 0xcf, 0xf2, 0xf8, 0x7c, 0x9d, 0xb1,
+	0x06, 0x86, 0xd0, 0x99, 0xe5, 0xf1, 0x09, 0x09, 0xcd, 0x3c, 0x17, 0xbc, 0x52, 0x32, 0x63, 0xbe,
+	0xcb, 0x7a, 0x91, 0x65, 0xac, 0x89, 0x03, 0x80, 0xe2, 0x3c, 0xa7, 0x3c, 0x63, 0x81, 0x4b, 0xfc,
+	0x5e, 0x6a, 0x62, 0x2d, 0x23, 0xc2, 0x05, 0x96, 0x6d, 0x3b, 0xd6, 0x2c, 0x13, 0xeb, 0x20, 0x83,
+	0xbe, 0x69, 0x46, 0x42, 0xe9, 0x6b, 0xd3, 0xa5, 0x8b, 0x43, 0x60, 0x55, 0xc4, 0x5e, 0xea, 0x21,
+	0xc2, 0x60, 0x96, 0xc7, 0x6f, 0x52, 0x45, 0x62, 0x71, 0x23, 0xae, 0x6f, 0x89, 0x01, 0xee, 0xc1,
+	0x8e, 0x2b, 0x64, 0x1e, 0x6f, 0x9d, 0xb3, 0xd0, 0xa5, 0x9d, 0xde, 0xd0, 0xe2, 0x97, 0xef, 0xd6,
+	0x52, 0xad, 0x13, 0xd6, 0xc7, 0x8f, 0x60, 0x6f, 0x96, 0xc7, 0x57, 0x4a, 0xa4, 0xf9, 0x92, 0xd4,
+	0x4b, 0x12, 0x11, 0x29, 0xb6, 0xe3, 0x6e, 0x5f, 0xad, 0x12, 0x92, 0x6b, 0x7d, 0x29, 0x7f, 0x65,
+	0x03, 0x27, 0x66, 0x4e, 0x22, 0xb2, 0x3f, 0x43, 0xb6, 0xeb, 0xc4, 0x6c, 0x10, 0x2b, 0x86, 0xb9,
+	0x79, 0x5f, 0x29, 0xb2, 0x23, 0xee, 0xb9, 0xae, 0x2e, 0xb6, 0x39, 0x78, 0x78, 0x07, 0x83, 0xfa,
+	0xf3, 0x1a, 0x1d, 0x5b, 0xe4, 0x45, 0x14, 0x99, 0xb7, 0x64, 0x0d, 0xe4, 0x30, 0xdc, 0xc2, 0x73,
+	0x4a, 0xe4, 0x5b, 0xb2, 0x8c, 0x57, 0x67, 0xde, 0x64, 0x91, 0xd0, 0x05, 0xe3, 0xe3, 0x01, 0xf0,
+	0x5a, 0xa9, 0x97, 0xc5, 0x36, 0x5a, 0xb6, 0x79, 0xc2, 0xef, 0x3f, 0x8c, 0x1a, 0xef, 0x3f, 0x8c,
+	0x1a, 0xf7, 0x0f, 0x23, 0xef, 0xfd, 0xc3, 0xc8, 0xfb, 0xf7, 0x61, 0xe4, 0xfd, 0xf9, 0xdf, 0xa8,
+	0xf1, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x86, 0x52, 0x5b, 0xe0, 0x74, 0x06, 0x00, 0x00,
 }
diff --git a/vendor/github.com/coreos/etcd/raft/raftpb/raft.proto b/vendor/github.com/coreos/etcd/raft/raftpb/raft.proto
index 806a43634fd..644ce7b8f2f 100644
--- a/vendor/github.com/coreos/etcd/raft/raftpb/raft.proto
+++ b/vendor/github.com/coreos/etcd/raft/raftpb/raft.proto
@@ -76,13 +76,15 @@ message HardState {
 }
 
 message ConfState {
-	repeated uint64 nodes = 1;
+	repeated uint64 nodes    = 1;
+	repeated uint64 learners = 2;
 }
 
 enum ConfChangeType {
-	ConfChangeAddNode    = 0;
-	ConfChangeRemoveNode = 1;
-	ConfChangeUpdateNode = 2;
+	ConfChangeAddNode        = 0;
+	ConfChangeRemoveNode     = 1;
+	ConfChangeUpdateNode     = 2;
+	ConfChangeAddLearnerNode = 3;
 }
 
 message ConfChange {
diff --git a/vendor/github.com/coreos/etcd/raft/rawnode.go b/vendor/github.com/coreos/etcd/raft/rawnode.go
index b950d5169a5..925cb851c4a 100644
--- a/vendor/github.com/coreos/etcd/raft/rawnode.go
+++ b/vendor/github.com/coreos/etcd/raft/rawnode.go
@@ -175,6 +175,8 @@ func (rn *RawNode) ApplyConfChange(cc pb.ConfChange) *pb.ConfState {
 	switch cc.Type {
 	case pb.ConfChangeAddNode:
 		rn.raft.addNode(cc.NodeID)
+	case pb.ConfChangeAddLearnerNode:
+		rn.raft.addLearner(cc.NodeID)
 	case pb.ConfChangeRemoveNode:
 		rn.raft.removeNode(cc.NodeID)
 	case pb.ConfChangeUpdateNode:
@@ -191,7 +193,7 @@ func (rn *RawNode) Step(m pb.Message) error {
 	if IsLocalMsg(m.Type) {
 		return ErrStepLocalMsg
 	}
-	if _, ok := rn.raft.prs[m.From]; ok || !IsResponseMsg(m.Type) {
+	if pr := rn.raft.getProgress(m.From); pr != nil || !IsResponseMsg(m.Type) {
 		return rn.raft.Step(m)
 	}
 	return ErrStepPeerNotFound
diff --git a/vendor/github.com/coreos/etcd/raft/read_only.go b/vendor/github.com/coreos/etcd/raft/read_only.go
index d0085237e36..ae746fa73eb 100644
--- a/vendor/github.com/coreos/etcd/raft/read_only.go
+++ b/vendor/github.com/coreos/etcd/raft/read_only.go
@@ -18,7 +18,7 @@ import pb "github.com/coreos/etcd/raft/raftpb"
 
 // ReadState provides state for read only query.
 // It's caller's responsibility to call ReadIndex first before getting
-// this state from ready, It's also caller's duty to differentiate if this
+// this state from ready, it's also caller's duty to differentiate if this
 // state is what it requests through RequestCtx, eg. given a unique id as
 // RequestCtx
 type ReadState struct {
diff --git a/vendor/github.com/coreos/etcd/raft/status.go b/vendor/github.com/coreos/etcd/raft/status.go
index b690fa56b95..f4d3d86a4e3 100644
--- a/vendor/github.com/coreos/etcd/raft/status.go
+++ b/vendor/github.com/coreos/etcd/raft/status.go
@@ -28,11 +28,17 @@ type Status struct {
 
 	Applied  uint64
 	Progress map[uint64]Progress
+
+	LeadTransferee uint64
 }
 
 // getStatus gets a copy of the current raft status.
 func getStatus(r *raft) Status {
-	s := Status{ID: r.id}
+	s := Status{
+		ID:             r.id,
+		LeadTransferee: r.leadTransferee,
+	}
+
 	s.HardState = r.hardState()
 	s.SoftState = *r.softState()
 
@@ -43,6 +49,10 @@ func getStatus(r *raft) Status {
 		for id, p := range r.prs {
 			s.Progress[id] = *p
 		}
+
+		for id, p := range r.learnerPrs {
+			s.Progress[id] = *p
+		}
 	}
 
 	return s
@@ -51,19 +61,21 @@ func getStatus(r *raft) Status {
 // MarshalJSON translates the raft status into JSON.
 // TODO: try to simplify this by introducing ID type into raft
 func (s Status) MarshalJSON() ([]byte, error) {
-	j := fmt.Sprintf(`{"id":"%x","term":%d,"vote":"%x","commit":%d,"lead":"%x","raftState":%q,"progress":{`,
-		s.ID, s.Term, s.Vote, s.Commit, s.Lead, s.RaftState)
+	j := fmt.Sprintf(`{"id":"%x","term":%d,"vote":"%x","commit":%d,"lead":"%x","raftState":%q,"applied":%d,"progress":{`,
+		s.ID, s.Term, s.Vote, s.Commit, s.Lead, s.RaftState, s.Applied)
 
 	if len(s.Progress) == 0 {
-		j += "}}"
+		j += "},"
 	} else {
 		for k, v := range s.Progress {
 			subj := fmt.Sprintf(`"%x":{"match":%d,"next":%d,"state":%q},`, k, v.Match, v.Next, v.State)
 			j += subj
 		}
 		// remove the trailing ","
-		j = j[:len(j)-1] + "}}"
+		j = j[:len(j)-1] + "},"
 	}
+
+	j += fmt.Sprintf(`"leadtransferee":"%x"}`, s.LeadTransferee)
 	return []byte(j), nil
 }
 
diff --git a/vendor/github.com/coreos/etcd/rafthttp/BUILD b/vendor/github.com/coreos/etcd/rafthttp/BUILD
index f56afd589bf..5fe93c041c6 100644
--- a/vendor/github.com/coreos/etcd/rafthttp/BUILD
+++ b/vendor/github.com/coreos/etcd/rafthttp/BUILD
@@ -39,7 +39,7 @@ go_library(
         "//vendor/github.com/coreos/pkg/capnslog:go_default_library",
         "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
         "//vendor/github.com/xiang90/probing:go_default_library",
-        "//vendor/golang.org/x/net/context:go_default_library",
+        "//vendor/golang.org/x/time/rate:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/coreos/etcd/rafthttp/http.go b/vendor/github.com/coreos/etcd/rafthttp/http.go
index 55df26e9b75..cc89e171ee2 100644
--- a/vendor/github.com/coreos/etcd/rafthttp/http.go
+++ b/vendor/github.com/coreos/etcd/rafthttp/http.go
@@ -15,6 +15,7 @@
 package rafthttp
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"io/ioutil"
@@ -27,7 +28,6 @@ import (
 	"github.com/coreos/etcd/raft/raftpb"
 	"github.com/coreos/etcd/snap"
 	"github.com/coreos/etcd/version"
-	"golang.org/x/net/context"
 )
 
 const (
@@ -91,11 +91,7 @@ func (h *pipelineHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if from, err := types.IDFromString(r.Header.Get("X-Server-From")); err != nil {
-		if urls := r.Header.Get("X-PeerURLs"); urls != "" {
-			h.tr.AddRemote(from, strings.Split(urls, ","))
-		}
-	}
+	addRemoteFromRequest(h.tr, r)
 
 	// Limit the data size that could be read from the request body, which ensures that read from
 	// connection will not time out accidentally due to possible blocking in underlying implementation.
@@ -176,11 +172,7 @@ func (h *snapshotHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if from, err := types.IDFromString(r.Header.Get("X-Server-From")); err != nil {
-		if urls := r.Header.Get("X-PeerURLs"); urls != "" {
-			h.tr.AddRemote(from, strings.Split(urls, ","))
-		}
-	}
+	addRemoteFromRequest(h.tr, r)
 
 	dec := &messageDecoder{r: r.Body}
 	// let snapshots be very large since they can exceed 512MB for large installations
diff --git a/vendor/github.com/coreos/etcd/rafthttp/peer.go b/vendor/github.com/coreos/etcd/rafthttp/peer.go
index 77f9ee464d9..e9a25bb3aa9 100644
--- a/vendor/github.com/coreos/etcd/rafthttp/peer.go
+++ b/vendor/github.com/coreos/etcd/rafthttp/peer.go
@@ -15,6 +15,7 @@
 package rafthttp
 
 import (
+	"context"
 	"sync"
 	"time"
 
@@ -23,7 +24,8 @@ import (
 	"github.com/coreos/etcd/raft"
 	"github.com/coreos/etcd/raft/raftpb"
 	"github.com/coreos/etcd/snap"
-	"golang.org/x/net/context"
+
+	"golang.org/x/time/rate"
 )
 
 const (
@@ -188,6 +190,7 @@ func startPeer(transport *Transport, urls types.URLs, peerID types.ID, fs *stats
 		status: status,
 		recvc:  p.recvc,
 		propc:  p.propc,
+		rl:     rate.NewLimiter(transport.DialRetryFrequency, 1),
 	}
 	p.msgAppReader = &streamReader{
 		peerID: peerID,
@@ -197,7 +200,9 @@ func startPeer(transport *Transport, urls types.URLs, peerID types.ID, fs *stats
 		status: status,
 		recvc:  p.recvc,
 		propc:  p.propc,
+		rl:     rate.NewLimiter(transport.DialRetryFrequency, 1),
 	}
+
 	p.msgAppV2Reader.start()
 	p.msgAppReader.start()
 
diff --git a/vendor/github.com/coreos/etcd/rafthttp/stream.go b/vendor/github.com/coreos/etcd/rafthttp/stream.go
index 2a6c620f56d..af49c18b1d9 100644
--- a/vendor/github.com/coreos/etcd/rafthttp/stream.go
+++ b/vendor/github.com/coreos/etcd/rafthttp/stream.go
@@ -25,6 +25,8 @@ import (
 	"sync"
 	"time"
 
+	"golang.org/x/time/rate"
+
 	"github.com/coreos/etcd/etcdserver/stats"
 	"github.com/coreos/etcd/pkg/httputil"
 	"github.com/coreos/etcd/pkg/transport"
@@ -53,6 +55,7 @@ var (
 		"3.0.0": {streamTypeMsgAppV2, streamTypeMessage},
 		"3.1.0": {streamTypeMsgAppV2, streamTypeMessage},
 		"3.2.0": {streamTypeMsgAppV2, streamTypeMessage},
+		"3.3.0": {streamTypeMsgAppV2, streamTypeMessage},
 	}
 )
 
@@ -243,7 +246,9 @@ func (cw *streamWriter) closeUnlocked() bool {
 	if !cw.working {
 		return false
 	}
-	cw.closer.Close()
+	if err := cw.closer.Close(); err != nil {
+		plog.Errorf("peer %s (writer) connection close error: %v", cw.peerID, err)
+	}
 	if len(cw.msgc) > 0 {
 		cw.r.ReportUnreachable(uint64(cw.peerID))
 	}
@@ -278,25 +283,28 @@ type streamReader struct {
 	recvc  chan<- raftpb.Message
 	propc  chan<- raftpb.Message
 
+	rl *rate.Limiter // alters the frequency of dial retrial attempts
+
 	errorc chan<- error
 
 	mu     sync.Mutex
 	paused bool
-	cancel func()
 	closer io.Closer
 
-	stopc chan struct{}
-	done  chan struct{}
+	ctx    context.Context
+	cancel context.CancelFunc
+	done   chan struct{}
 }
 
-func (r *streamReader) start() {
-	r.stopc = make(chan struct{})
-	r.done = make(chan struct{})
-	if r.errorc == nil {
-		r.errorc = r.tr.ErrorC
+func (cr *streamReader) start() {
+	cr.done = make(chan struct{})
+	if cr.errorc == nil {
+		cr.errorc = cr.tr.ErrorC
 	}
-
-	go r.run()
+	if cr.ctx == nil {
+		cr.ctx, cr.cancel = context.WithCancel(context.Background())
+	}
+	go cr.run()
 }
 
 func (cr *streamReader) run() {
@@ -311,7 +319,7 @@ func (cr *streamReader) run() {
 		} else {
 			cr.status.activate()
 			plog.Infof("established a TCP streaming connection with peer %s (%s reader)", cr.peerID, cr.typ)
-			err := cr.decodeLoop(rc, t)
+			err = cr.decodeLoop(rc, t)
 			plog.Warningf("lost the TCP streaming connection with peer %s (%s reader)", cr.peerID, cr.typ)
 			switch {
 			// all data is read out
@@ -322,15 +330,16 @@ func (cr *streamReader) run() {
 				cr.status.deactivate(failureType{source: t.String(), action: "read"}, err.Error())
 			}
 		}
-		select {
-		// Wait 100ms to create a new stream, so it doesn't bring too much
-		// overhead when retry.
-		case <-time.After(100 * time.Millisecond):
-		case <-cr.stopc:
+		// Wait for a while before new dial attempt
+		err = cr.rl.Wait(cr.ctx)
+		if cr.ctx.Err() != nil {
 			plog.Infof("stopped streaming with peer %s (%s reader)", cr.peerID, t)
 			close(cr.done)
 			return
 		}
+		if err != nil {
+			plog.Errorf("streaming with peer %s (%s reader) rate limiter error: %v", cr.peerID, t, err)
+		}
 	}
 }
 
@@ -346,7 +355,7 @@ func (cr *streamReader) decodeLoop(rc io.ReadCloser, t streamType) error {
 		plog.Panicf("unhandled stream type %s", t)
 	}
 	select {
-	case <-cr.stopc:
+	case <-cr.ctx.Done():
 		cr.mu.Unlock()
 		if err := rc.Close(); err != nil {
 			return err
@@ -401,11 +410,8 @@ func (cr *streamReader) decodeLoop(rc io.ReadCloser, t streamType) error {
 }
 
 func (cr *streamReader) stop() {
-	close(cr.stopc)
 	cr.mu.Lock()
-	if cr.cancel != nil {
-		cr.cancel()
-	}
+	cr.cancel()
 	cr.close()
 	cr.mu.Unlock()
 	<-cr.done
@@ -429,13 +435,11 @@ func (cr *streamReader) dial(t streamType) (io.ReadCloser, error) {
 
 	setPeerURLsHeader(req, cr.tr.URLs)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	req = req.WithContext(ctx)
+	req = req.WithContext(cr.ctx)
 
 	cr.mu.Lock()
-	cr.cancel = cancel
 	select {
-	case <-cr.stopc:
+	case <-cr.ctx.Done():
 		cr.mu.Unlock()
 		return nil, fmt.Errorf("stream reader is stopped")
 	default:
@@ -497,7 +501,9 @@ func (cr *streamReader) dial(t streamType) (io.ReadCloser, error) {
 
 func (cr *streamReader) close() {
 	if cr.closer != nil {
-		cr.closer.Close()
+		if err := cr.closer.Close(); err != nil {
+			plog.Errorf("peer %s (reader) connection close error: %v", cr.peerID, err)
+		}
 	}
 	cr.closer = nil
 }
diff --git a/vendor/github.com/coreos/etcd/rafthttp/transport.go b/vendor/github.com/coreos/etcd/rafthttp/transport.go
index f96149aa393..ce73433027b 100644
--- a/vendor/github.com/coreos/etcd/rafthttp/transport.go
+++ b/vendor/github.com/coreos/etcd/rafthttp/transport.go
@@ -15,6 +15,7 @@
 package rafthttp
 
 import (
+	"context"
 	"net/http"
 	"sync"
 	"time"
@@ -26,9 +27,10 @@ import (
 	"github.com/coreos/etcd/raft"
 	"github.com/coreos/etcd/raft/raftpb"
 	"github.com/coreos/etcd/snap"
+
 	"github.com/coreos/pkg/capnslog"
 	"github.com/xiang90/probing"
-	"golang.org/x/net/context"
+	"golang.org/x/time/rate"
 )
 
 var plog = logutil.NewMergeLogger(capnslog.NewPackageLogger("github.com/coreos/etcd", "rafthttp"))
@@ -96,8 +98,12 @@ type Transporter interface {
 // User needs to call Start before calling other functions, and call
 // Stop when the Transport is no longer used.
 type Transport struct {
-	DialTimeout time.Duration     // maximum duration before timing out dial of the request
-	TLSInfo     transport.TLSInfo // TLS information used when creating connection
+	DialTimeout time.Duration // maximum duration before timing out dial of the request
+	// DialRetryFrequency defines the frequency of streamReader dial retrial attempts;
+	// a distinct rate limiter is created per every peer (default value: 10 events/sec)
+	DialRetryFrequency rate.Limit
+
+	TLSInfo transport.TLSInfo // TLS information used when creating connection
 
 	ID          types.ID   // local member ID
 	URLs        types.URLs // local peer URLs
@@ -137,6 +143,13 @@ func (t *Transport) Start() error {
 	t.remotes = make(map[types.ID]*remote)
 	t.peers = make(map[types.ID]Peer)
 	t.prober = probing.NewProber(t.pipelineRt)
+
+	// If client didn't provide dial retry frequency, use the default
+	// (100ms backoff between attempts to create a new stream),
+	// so it doesn't bring too much overhead when retry.
+	if t.DialRetryFrequency == 0 {
+		t.DialRetryFrequency = rate.Every(100 * time.Millisecond)
+	}
 	return nil
 }
 
diff --git a/vendor/github.com/coreos/etcd/rafthttp/util.go b/vendor/github.com/coreos/etcd/rafthttp/util.go
index 12e548c7717..6ec3641aa7a 100644
--- a/vendor/github.com/coreos/etcd/rafthttp/util.go
+++ b/vendor/github.com/coreos/etcd/rafthttp/util.go
@@ -175,3 +175,12 @@ func setPeerURLsHeader(req *http.Request, urls types.URLs) {
 	}
 	req.Header.Set("X-PeerURLs", strings.Join(peerURLs, ","))
 }
+
+// addRemoteFromRequest adds a remote peer according to an http request header
+func addRemoteFromRequest(tr Transporter, r *http.Request) {
+	if from, err := types.IDFromString(r.Header.Get("X-Server-From")); err == nil {
+		if urls := r.Header.Get("X-PeerURLs"); urls != "" {
+			tr.AddRemote(from, strings.Split(urls, ","))
+		}
+	}
+}
diff --git a/vendor/github.com/coreos/etcd/snap/snappb/BUILD b/vendor/github.com/coreos/etcd/snap/snappb/BUILD
index 96c142b8c45..9b4bd33b26b 100644
--- a/vendor/github.com/coreos/etcd/snap/snappb/BUILD
+++ b/vendor/github.com/coreos/etcd/snap/snappb/BUILD
@@ -6,7 +6,10 @@ go_library(
     importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/snap/snappb",
     importpath = "github.com/coreos/etcd/snap/snappb",
     visibility = ["//visibility:public"],
-    deps = ["//vendor/github.com/golang/protobuf/proto:go_default_library"],
+    deps = [
+        "//vendor/github.com/gogo/protobuf/gogoproto:go_default_library",
+        "//vendor/github.com/golang/protobuf/proto:go_default_library",
+    ],
 )
 
 filegroup(
diff --git a/vendor/github.com/coreos/etcd/snap/snappb/snap.pb.go b/vendor/github.com/coreos/etcd/snap/snappb/snap.pb.go
index 05a77ff9d06..e72b577f5b8 100644
--- a/vendor/github.com/coreos/etcd/snap/snappb/snap.pb.go
+++ b/vendor/github.com/coreos/etcd/snap/snappb/snap.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: snap.proto
-// DO NOT EDIT!
 
 /*
 	Package snappb is a generated protocol buffer package.
@@ -20,6 +19,8 @@ import (
 
 	math "math"
 
+	_ "github.com/gogo/protobuf/gogoproto"
+
 	io "io"
 )
 
@@ -78,24 +79,6 @@ func (m *Snapshot) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Snap(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Snap(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintSnap(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/coreos/etcd/store/metrics.go b/vendor/github.com/coreos/etcd/store/metrics.go
index 26404ba72e3..077c0fa23ea 100644
--- a/vendor/github.com/coreos/etcd/store/metrics.go
+++ b/vendor/github.com/coreos/etcd/store/metrics.go
@@ -86,7 +86,11 @@ const (
 )
 
 func init() {
-	prometheus.MustRegister(readCounter)
+	if prometheus.Register(readCounter) != nil {
+		// Tests will try to double register since the tests use both
+		// store and store_test packages; ignore second attempts.
+		return
+	}
 	prometheus.MustRegister(writeCounter)
 	prometheus.MustRegister(expireCounter)
 	prometheus.MustRegister(watchRequests)
diff --git a/vendor/github.com/coreos/etcd/store/node.go b/vendor/github.com/coreos/etcd/store/node.go
index 54159553500..c3c87431cb8 100644
--- a/vendor/github.com/coreos/etcd/store/node.go
+++ b/vendor/github.com/coreos/etcd/store/node.go
@@ -350,7 +350,7 @@ func (n *node) Compare(prevValue string, prevIndex uint64) (ok bool, which int)
 	default:
 		which = CompareNotMatch
 	}
-	return
+	return ok, which
 }
 
 // Clone function clone the node recursively and return the new node.
diff --git a/vendor/github.com/coreos/etcd/store/stats.go b/vendor/github.com/coreos/etcd/store/stats.go
index 59b45f2b8b3..ce464dda6b8 100644
--- a/vendor/github.com/coreos/etcd/store/stats.go
+++ b/vendor/github.com/coreos/etcd/store/stats.go
@@ -38,7 +38,6 @@ const (
 )
 
 type Stats struct {
-
 	// Number of get requests
 
 	GetSuccess uint64 `json:"getsSuccess"`
diff --git a/vendor/github.com/coreos/etcd/version/version.go b/vendor/github.com/coreos/etcd/version/version.go
index e09b88332a9..156e0f11af9 100644
--- a/vendor/github.com/coreos/etcd/version/version.go
+++ b/vendor/github.com/coreos/etcd/version/version.go
@@ -26,7 +26,7 @@ import (
 var (
 	// MinClusterVersion is the min cluster version this etcd binary is compatible with.
 	MinClusterVersion = "3.0.0"
-	Version           = "3.2.24"
+	Version           = "3.3.9"
 	APIVersion        = "unknown"
 
 	// Git SHA Value will be set during build
diff --git a/vendor/github.com/coreos/etcd/wal/BUILD b/vendor/github.com/coreos/etcd/wal/BUILD
index 9837ddfa1c3..c5d0eb57d75 100644
--- a/vendor/github.com/coreos/etcd/wal/BUILD
+++ b/vendor/github.com/coreos/etcd/wal/BUILD
@@ -11,8 +11,6 @@ go_library(
         "repair.go",
         "util.go",
         "wal.go",
-        "wal_unix.go",
-        "wal_windows.go",
     ],
     importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/wal",
     importpath = "github.com/coreos/etcd/wal",
diff --git a/vendor/github.com/coreos/etcd/wal/decoder.go b/vendor/github.com/coreos/etcd/wal/decoder.go
index 0d9b4428c94..6a217f897b0 100644
--- a/vendor/github.com/coreos/etcd/wal/decoder.go
+++ b/vendor/github.com/coreos/etcd/wal/decoder.go
@@ -29,6 +29,9 @@ import (
 
 const minSectorSize = 512
 
+// frameSizeBytes is frame size in bytes, including record size and padding size.
+const frameSizeBytes = 8
+
 type decoder struct {
 	mu  sync.Mutex
 	brs []*bufio.Reader
@@ -104,7 +107,7 @@ func (d *decoder) decodeRecord(rec *walpb.Record) error {
 		}
 	}
 	// record decoded as valid; point last valid offset to end of record
-	d.lastValidOff += recBytes + padBytes + 8
+	d.lastValidOff += frameSizeBytes + recBytes + padBytes
 	return nil
 }
 
@@ -116,7 +119,7 @@ func decodeFrameSize(lenField int64) (recBytes int64, padBytes int64) {
 		// padding is stored in lower 3 bits of length MSB
 		padBytes = int64((uint64(lenField) >> 56) & 0x7)
 	}
-	return
+	return recBytes, padBytes
 }
 
 // isTornEntry determines whether the last entry of the WAL was partially written
@@ -126,7 +129,7 @@ func (d *decoder) isTornEntry(data []byte) bool {
 		return false
 	}
 
-	fileOff := d.lastValidOff + 8
+	fileOff := d.lastValidOff + frameSizeBytes
 	curOff := 0
 	chunks := [][]byte{}
 	// split data on sector boundaries
diff --git a/vendor/github.com/coreos/etcd/wal/encoder.go b/vendor/github.com/coreos/etcd/wal/encoder.go
index aac1e197e59..e8040b8dff1 100644
--- a/vendor/github.com/coreos/etcd/wal/encoder.go
+++ b/vendor/github.com/coreos/etcd/wal/encoder.go
@@ -103,7 +103,7 @@ func encodeFrameSize(dataBytes int) (lenField uint64, padBytes int) {
 	if padBytes != 0 {
 		lenField |= uint64(0x80|padBytes) << 56
 	}
-	return
+	return lenField, padBytes
 }
 
 func (e *encoder) flush() error {
diff --git a/vendor/github.com/coreos/etcd/wal/file_pipeline.go b/vendor/github.com/coreos/etcd/wal/file_pipeline.go
index 5e32a0693c1..3a1c57c1c96 100644
--- a/vendor/github.com/coreos/etcd/wal/file_pipeline.go
+++ b/vendor/github.com/coreos/etcd/wal/file_pipeline.go
@@ -55,7 +55,7 @@ func (fp *filePipeline) Open() (f *fileutil.LockedFile, err error) {
 	case f = <-fp.filec:
 	case err = <-fp.errc:
 	}
-	return
+	return f, err
 }
 
 func (fp *filePipeline) Close() error {
diff --git a/vendor/github.com/coreos/etcd/wal/wal.go b/vendor/github.com/coreos/etcd/wal/wal.go
index 2cac25c1c90..96d01a23af6 100644
--- a/vendor/github.com/coreos/etcd/wal/wal.go
+++ b/vendor/github.com/coreos/etcd/wal/wal.go
@@ -157,6 +157,48 @@ func Create(dirpath string, metadata []byte) (*WAL, error) {
 	return w, nil
 }
 
+func (w *WAL) renameWal(tmpdirpath string) (*WAL, error) {
+	if err := os.RemoveAll(w.dir); err != nil {
+		return nil, err
+	}
+	// On non-Windows platforms, hold the lock while renaming. Releasing
+	// the lock and trying to reacquire it quickly can be flaky because
+	// it's possible the process will fork to spawn a process while this is
+	// happening. The fds are set up as close-on-exec by the Go runtime,
+	// but there is a window between the fork and the exec where another
+	// process holds the lock.
+	if err := os.Rename(tmpdirpath, w.dir); err != nil {
+		if _, ok := err.(*os.LinkError); ok {
+			return w.renameWalUnlock(tmpdirpath)
+		}
+		return nil, err
+	}
+	w.fp = newFilePipeline(w.dir, SegmentSizeBytes)
+	df, err := fileutil.OpenDir(w.dir)
+	w.dirFile = df
+	return w, err
+}
+
+func (w *WAL) renameWalUnlock(tmpdirpath string) (*WAL, error) {
+	// rename of directory with locked files doesn't work on windows/cifs;
+	// close the WAL to release the locks so the directory can be renamed.
+	plog.Infof("releasing file lock to rename %q to %q", tmpdirpath, w.dir)
+	w.Close()
+	if err := os.Rename(tmpdirpath, w.dir); err != nil {
+		return nil, err
+	}
+	// reopen and relock
+	newWAL, oerr := Open(w.dir, walpb.Snapshot{})
+	if oerr != nil {
+		return nil, oerr
+	}
+	if _, _, _, err := newWAL.ReadAll(); err != nil {
+		newWAL.Close()
+		return nil, err
+	}
+	return newWAL, nil
+}
+
 // Open opens the WAL at the given snap.
 // The snap SHOULD have been previously saved to the WAL, or the following
 // ReadAll will fail.
@@ -413,6 +455,7 @@ func (w *WAL) cut() error {
 		return err
 	}
 
+	// reopen newTail with its new path so calls to Name() match the wal filename format
 	newTail.Close()
 
 	if newTail, err = fileutil.LockFile(fpath, os.O_WRONLY, fileutil.PrivateFileMode); err != nil {
@@ -460,6 +503,10 @@ func (w *WAL) ReleaseLockTo(index uint64) error {
 	w.mu.Lock()
 	defer w.mu.Unlock()
 
+	if len(w.locks) == 0 {
+		return nil
+	}
+
 	var smaller int
 	found := false
 
@@ -477,7 +524,7 @@ func (w *WAL) ReleaseLockTo(index uint64) error {
 
 	// if no lock index is greater than the release index, we can
 	// release lock up to the last one(excluding).
-	if !found && len(w.locks) != 0 {
+	if !found {
 		smaller = len(w.locks) - 1
 	}
 
diff --git a/vendor/github.com/coreos/etcd/wal/wal_unix.go b/vendor/github.com/coreos/etcd/wal/wal_unix.go
deleted file mode 100644
index 82fd6a17a74..00000000000
--- a/vendor/github.com/coreos/etcd/wal/wal_unix.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2016 The etcd Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// +build !windows
-
-package wal
-
-import (
-	"os"
-
-	"github.com/coreos/etcd/pkg/fileutil"
-)
-
-func (w *WAL) renameWal(tmpdirpath string) (*WAL, error) {
-	// On non-Windows platforms, hold the lock while renaming. Releasing
-	// the lock and trying to reacquire it quickly can be flaky because
-	// it's possible the process will fork to spawn a process while this is
-	// happening. The fds are set up as close-on-exec by the Go runtime,
-	// but there is a window between the fork and the exec where another
-	// process holds the lock.
-
-	if err := os.RemoveAll(w.dir); err != nil {
-		return nil, err
-	}
-	if err := os.Rename(tmpdirpath, w.dir); err != nil {
-		return nil, err
-	}
-
-	w.fp = newFilePipeline(w.dir, SegmentSizeBytes)
-	df, err := fileutil.OpenDir(w.dir)
-	w.dirFile = df
-	return w, err
-}
diff --git a/vendor/github.com/coreos/etcd/wal/wal_windows.go b/vendor/github.com/coreos/etcd/wal/wal_windows.go
deleted file mode 100644
index 0b9e434cf54..00000000000
--- a/vendor/github.com/coreos/etcd/wal/wal_windows.go
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2016 The etcd Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package wal
-
-import (
-	"os"
-
-	"github.com/coreos/etcd/wal/walpb"
-)
-
-func (w *WAL) renameWal(tmpdirpath string) (*WAL, error) {
-	// rename of directory with locked files doesn't work on
-	// windows; close the WAL to release the locks so the directory
-	// can be renamed
-	w.Close()
-	if err := os.Rename(tmpdirpath, w.dir); err != nil {
-		return nil, err
-	}
-	// reopen and relock
-	newWAL, oerr := Open(w.dir, walpb.Snapshot{})
-	if oerr != nil {
-		return nil, oerr
-	}
-	if _, _, _, err := newWAL.ReadAll(); err != nil {
-		newWAL.Close()
-		return nil, err
-	}
-	return newWAL, nil
-}
diff --git a/vendor/github.com/coreos/etcd/wal/walpb/BUILD b/vendor/github.com/coreos/etcd/wal/walpb/BUILD
index 498f396dd49..804102ce8a2 100644
--- a/vendor/github.com/coreos/etcd/wal/walpb/BUILD
+++ b/vendor/github.com/coreos/etcd/wal/walpb/BUILD
@@ -9,7 +9,10 @@ go_library(
     importmap = "k8s.io/kubernetes/vendor/github.com/coreos/etcd/wal/walpb",
     importpath = "github.com/coreos/etcd/wal/walpb",
     visibility = ["//visibility:public"],
-    deps = ["//vendor/github.com/golang/protobuf/proto:go_default_library"],
+    deps = [
+        "//vendor/github.com/gogo/protobuf/gogoproto:go_default_library",
+        "//vendor/github.com/golang/protobuf/proto:go_default_library",
+    ],
 )
 
 filegroup(
diff --git a/vendor/github.com/coreos/etcd/wal/walpb/record.pb.go b/vendor/github.com/coreos/etcd/wal/walpb/record.pb.go
index 664fae1305b..3ce63ddc2eb 100644
--- a/vendor/github.com/coreos/etcd/wal/walpb/record.pb.go
+++ b/vendor/github.com/coreos/etcd/wal/walpb/record.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: record.proto
-// DO NOT EDIT!
 
 /*
 	Package walpb is a generated protocol buffer package.
@@ -21,6 +20,8 @@ import (
 
 	math "math"
 
+	_ "github.com/gogo/protobuf/gogoproto"
+
 	io "io"
 )
 
@@ -122,24 +123,6 @@ func (m *Snapshot) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Record(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Record(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintRecord(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/gogo/protobuf/AUTHORS b/vendor/github.com/gogo/protobuf/AUTHORS
index 2eaf4d53a0c..3d97fc7a29f 100644
--- a/vendor/github.com/gogo/protobuf/AUTHORS
+++ b/vendor/github.com/gogo/protobuf/AUTHORS
@@ -10,5 +10,6 @@
 
 # Please keep the list sorted.
 
+Sendgrid, Inc
 Vastech SA (PTY) LTD
 Walter Schulze <awalterschulze@gmail.com>
diff --git a/vendor/github.com/gogo/protobuf/CONTRIBUTORS b/vendor/github.com/gogo/protobuf/CONTRIBUTORS
index 84a85b1e88d..b1abc4d305d 100644
--- a/vendor/github.com/gogo/protobuf/CONTRIBUTORS
+++ b/vendor/github.com/gogo/protobuf/CONTRIBUTORS
@@ -1,4 +1,5 @@
 Anton Povarov <anton.povarov@gmail.com>
+Brian Goff <cpuguy83@gmail.com>
 Clayton Coleman <ccoleman@redhat.com>
 Denis Smirnov <denis.smirnov.91@gmail.com>
 DongYun Kang <ceram1000@gmail.com>
@@ -10,9 +11,12 @@ John Shahid <jvshahid@gmail.com>
 John Tuley <john@tuley.org>
 Laurent <laurent@adyoulike.com>
 Patrick Lee <patrick@dropbox.com>
+Roger Johansson <rogeralsing@gmail.com>
+Sam Nguyen <sam.nguyen@sendgrid.com>
 Sergio Arbeo <serabe@gmail.com>
 Stephen J Day <stephen.day@docker.com>
 Tamir Duberstein <tamird@gmail.com>
 Todd Eisenberger <teisenberger@dropbox.com>
 Tormod Erevik Lea <tormodlea@gmail.com>
+Vyacheslav Kim <kane@sendgrid.com>
 Walter Schulze <awalterschulze@gmail.com>
diff --git a/vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go b/vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go
index 9506b6fb205..fa88040f117 100644
--- a/vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go
+++ b/vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: gogo.proto
-// DO NOT EDIT!
 
 /*
 Package gogoproto is a generated protocol buffer package.
diff --git a/vendor/github.com/gogo/protobuf/plugin/compare/compare.go b/vendor/github.com/gogo/protobuf/plugin/compare/compare.go
index 75c0399af93..97d0a4a9aa2 100644
--- a/vendor/github.com/gogo/protobuf/plugin/compare/compare.go
+++ b/vendor/github.com/gogo/protobuf/plugin/compare/compare.go
@@ -512,7 +512,7 @@ func (p *plugin) generateMessage(file *generator.FileDescriptor, message *genera
 		p.In()
 
 		p.generateMsgNullAndTypeCheck(ccTypeName)
-		vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly(field)
+		vanity.TurnOffNullableForNativeTypes(field)
 		p.generateField(file, message, field)
 
 		p.P(`return 0`)
diff --git a/vendor/github.com/gogo/protobuf/plugin/equal/equal.go b/vendor/github.com/gogo/protobuf/plugin/equal/equal.go
index 6a422635d40..9d937e42f98 100644
--- a/vendor/github.com/gogo/protobuf/plugin/equal/equal.go
+++ b/vendor/github.com/gogo/protobuf/plugin/equal/equal.go
@@ -627,7 +627,7 @@ func (p *plugin) generateMessage(file *generator.FileDescriptor, message *genera
 		p.In()
 
 		p.generateMsgNullAndTypeCheck(ccTypeName, verbose)
-		vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly(field)
+		vanity.TurnOffNullableForNativeTypes(field)
 		p.generateField(file, message, field, verbose)
 
 		if verbose {
diff --git a/vendor/github.com/gogo/protobuf/plugin/gostring/gostring.go b/vendor/github.com/gogo/protobuf/plugin/gostring/gostring.go
index 024c9f0aaec..2b439469fcb 100644
--- a/vendor/github.com/gogo/protobuf/plugin/gostring/gostring.go
+++ b/vendor/github.com/gogo/protobuf/plugin/gostring/gostring.go
@@ -98,11 +98,12 @@ package gostring
 
 import (
 	"fmt"
-	"github.com/gogo/protobuf/gogoproto"
-	"github.com/gogo/protobuf/protoc-gen-gogo/generator"
 	"os"
 	"strconv"
 	"strings"
+
+	"github.com/gogo/protobuf/gogoproto"
+	"github.com/gogo/protobuf/protoc-gen-gogo/generator"
 )
 
 type gostring struct {
@@ -229,8 +230,22 @@ func (p *gostring) Generate(file *generator.FileDescriptor) {
 					p.P(`if this.`, fieldname, ` != nil {`)
 					p.In()
 				}
-				if nullable || repeated {
+				if nullable {
 					p.P(`s = append(s, "`, fieldname, `: " + `, fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `) + ",\n")`)
+				} else if repeated {
+					if nullable {
+						p.P(`s = append(s, "`, fieldname, `: " + `, fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `) + ",\n")`)
+					} else {
+						goTyp, _ := p.GoType(message, field)
+						goTyp = strings.Replace(goTyp, "[]", "", 1)
+						p.P("vs := make([]*", goTyp, ", len(this.", fieldname, "))")
+						p.P("for i := range vs {")
+						p.In()
+						p.P("vs[i] = &this.", fieldname, "[i]")
+						p.Out()
+						p.P("}")
+						p.P(`s = append(s, "`, fieldname, `: " + `, fmtPkg.Use(), `.Sprintf("%#v", vs) + ",\n")`)
+					}
 				} else {
 					p.P(`s = append(s, "`, fieldname, `: " + `, stringsPkg.Use(), `.Replace(this.`, fieldname, `.GoString()`, ",`&`,``,1)", ` + ",\n")`)
 				}
@@ -246,7 +261,7 @@ func (p *gostring) Generate(file *generator.FileDescriptor) {
 				if field.IsEnum() {
 					if nullable && !repeated && !proto3 {
 						goTyp, _ := p.GoType(message, field)
-						p.P(`s = append(s, "`, fieldname, `: " + valueToGoString`, p.localName, `(this.`, fieldname, `,"`, packageName, ".", generator.GoTypeToName(goTyp), `"`, `) + ",\n")`)
+						p.P(`s = append(s, "`, fieldname, `: " + valueToGoString`, p.localName, `(this.`, fieldname, `,"`, generator.GoTypeToName(goTyp), `"`, `) + ",\n")`)
 					} else {
 						p.P(`s = append(s, "`, fieldname, `: " + `, fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `) + ",\n")`)
 					}
@@ -285,7 +300,6 @@ func (p *gostring) Generate(file *generator.FileDescriptor) {
 		}
 
 		p.P(`s = append(s, "}")`)
-		//outStr += strings.Join([]string{" + `}`", `}`, `,", "`, ")"}, "")
 		p.P(`return `, stringsPkg.Use(), `.Join(s, "")`)
 		p.Out()
 		p.P(`}`)
@@ -304,20 +318,15 @@ func (p *gostring) Generate(file *generator.FileDescriptor) {
 			p.P(`return "nil"`)
 			p.Out()
 			p.P(`}`)
-			outFlds := []string{}
 			fieldname := p.GetOneOfFieldName(message, field)
-			if field.IsMessage() || p.IsGroup(field) {
-				tmp := strings.Join([]string{"`", fieldname, ":` + "}, "")
-				tmp += strings.Join([]string{fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `)`}, "")
-				outFlds = append(outFlds, tmp)
-			} else {
-				tmp := strings.Join([]string{"`", fieldname, ":` + "}, "")
-				tmp += strings.Join([]string{fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, ")"}, "")
-				outFlds = append(outFlds, tmp)
-			}
-			outStr := strings.Join([]string{"s := ", stringsPkg.Use(), ".Join([]string{`&", packageName, ".", ccTypeName, "{` + \n"}, "")
-			outStr += strings.Join(outFlds, ",\n")
-			outStr += strings.Join([]string{" + `}`", `}`, `,", "`, ")"}, "")
+			outStr := strings.Join([]string{
+				"s := ",
+				stringsPkg.Use(), ".Join([]string{`&", packageName, ".", ccTypeName, "{` + \n",
+				"`", fieldname, ":` + ", fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `)`,
+				" + `}`",
+				`}`,
+				`,", "`,
+				`)`}, "")
 			p.P(outStr)
 			p.P(`return s`)
 			p.Out()
diff --git a/vendor/github.com/gogo/protobuf/plugin/gostring/gostringtest.go b/vendor/github.com/gogo/protobuf/plugin/gostring/gostringtest.go
index c7e6c16980e..c790e590880 100644
--- a/vendor/github.com/gogo/protobuf/plugin/gostring/gostringtest.go
+++ b/vendor/github.com/gogo/protobuf/plugin/gostring/gostringtest.go
@@ -74,7 +74,7 @@ func (p *test) Generate(imports generator.PluginImports, file *generator.FileDes
 			p.P(`_, err := `, parserPkg.Use(), `.ParseExpr(s1)`)
 			p.P(`if err != nil {`)
 			p.In()
-			p.P(`panic(err)`)
+			p.P(`t.Fatal(err)`)
 			p.Out()
 			p.P(`}`)
 			p.Out()
diff --git a/vendor/github.com/gogo/protobuf/plugin/marshalto/marshalto.go b/vendor/github.com/gogo/protobuf/plugin/marshalto/marshalto.go
index b2631e6738c..24110cb4431 100644
--- a/vendor/github.com/gogo/protobuf/plugin/marshalto/marshalto.go
+++ b/vendor/github.com/gogo/protobuf/plugin/marshalto/marshalto.go
@@ -172,28 +172,20 @@ type marshalto struct {
 	*generator.Generator
 	generator.PluginImports
 	atleastOne  bool
-	unsafePkg   generator.Single
 	errorsPkg   generator.Single
 	protoPkg    generator.Single
 	sortKeysPkg generator.Single
 	mathPkg     generator.Single
 	typesPkg    generator.Single
+	binaryPkg   generator.Single
 	localName   string
-	unsafe      bool
 }
 
 func NewMarshal() *marshalto {
 	return &marshalto{}
 }
 
-func NewUnsafeMarshal() *marshalto {
-	return &marshalto{unsafe: true}
-}
-
 func (p *marshalto) Name() string {
-	if p.unsafe {
-		return "unsafemarshaler"
-	}
 	return "marshalto"
 }
 
@@ -202,11 +194,13 @@ func (p *marshalto) Init(g *generator.Generator) {
 }
 
 func (p *marshalto) callFixed64(varName ...string) {
-	p.P(`i = encodeFixed64`, p.localName, `(dAtA, i, uint64(`, strings.Join(varName, ""), `))`)
+	p.P(p.binaryPkg.Use(), `.LittleEndian.PutUint64(dAtA[i:], uint64(`, strings.Join(varName, ""), `))`)
+	p.P(`i += 8`)
 }
 
 func (p *marshalto) callFixed32(varName ...string) {
-	p.P(`i = encodeFixed32`, p.localName, `(dAtA, i, uint32(`, strings.Join(varName, ""), `))`)
+	p.P(p.binaryPkg.Use(), `.LittleEndian.PutUint32(dAtA[i:], uint32(`, strings.Join(varName, ""), `))`)
+	p.P(`i += 4`)
 }
 
 func (p *marshalto) callVarint(varName ...string) {
@@ -225,46 +219,6 @@ func (p *marshalto) encodeVarint(varName string) {
 	p.P(`i++`)
 }
 
-func (p *marshalto) encodeFixed64(varName string) {
-	p.P(`dAtA[i] = uint8(`, varName, `)`)
-	p.P(`i++`)
-	p.P(`dAtA[i] = uint8(`, varName, ` >> 8)`)
-	p.P(`i++`)
-	p.P(`dAtA[i] = uint8(`, varName, ` >> 16)`)
-	p.P(`i++`)
-	p.P(`dAtA[i] = uint8(`, varName, ` >> 24)`)
-	p.P(`i++`)
-	p.P(`dAtA[i] = uint8(`, varName, ` >> 32)`)
-	p.P(`i++`)
-	p.P(`dAtA[i] = uint8(`, varName, ` >> 40)`)
-	p.P(`i++`)
-	p.P(`dAtA[i] = uint8(`, varName, ` >> 48)`)
-	p.P(`i++`)
-	p.P(`dAtA[i] = uint8(`, varName, ` >> 56)`)
-	p.P(`i++`)
-}
-
-func (p *marshalto) unsafeFixed64(varName string, someType string) {
-	p.P(`*(*`, someType, `)(`, p.unsafePkg.Use(), `.Pointer(&dAtA[i])) = `, varName)
-	p.P(`i+=8`)
-}
-
-func (p *marshalto) encodeFixed32(varName string) {
-	p.P(`dAtA[i] = uint8(`, varName, `)`)
-	p.P(`i++`)
-	p.P(`dAtA[i] = uint8(`, varName, ` >> 8)`)
-	p.P(`i++`)
-	p.P(`dAtA[i] = uint8(`, varName, ` >> 16)`)
-	p.P(`i++`)
-	p.P(`dAtA[i] = uint8(`, varName, ` >> 24)`)
-	p.P(`i++`)
-}
-
-func (p *marshalto) unsafeFixed32(varName string, someType string) {
-	p.P(`*(*`, someType, `)(`, p.unsafePkg.Use(), `.Pointer(&dAtA[i])) = `, varName)
-	p.P(`i+=4`)
-}
-
 func (p *marshalto) encodeKey(fieldNumber int32, wireType int) {
 	x := uint32(fieldNumber)<<3 | uint32(wireType)
 	i := 0
@@ -428,132 +382,68 @@ func (p *marshalto) generateField(proto3 bool, numGen NumGen, file *generator.Fi
 	}
 	switch *field.Type {
 	case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
-		if !p.unsafe || gogoproto.IsCastType(field) {
-			if packed {
-				p.encodeKey(fieldNumber, wireType)
-				p.callVarint(`len(m.`, fieldname, `) * 8`)
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float64bits(float64(num))`)
-				p.encodeFixed64("f" + numGen.Current())
-				p.Out()
-				p.P(`}`)
-			} else if repeated {
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float64bits(float64(num))`)
-				p.encodeFixed64("f" + numGen.Current())
-				p.Out()
-				p.P(`}`)
-			} else if proto3 {
-				p.P(`if m.`, fieldname, ` != 0 {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed64(p.mathPkg.Use(), `.Float64bits(float64(m.`+fieldname, `))`)
-				p.Out()
-				p.P(`}`)
-			} else if !nullable {
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed64(p.mathPkg.Use(), `.Float64bits(float64(m.`+fieldname, `))`)
-			} else {
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed64(p.mathPkg.Use(), `.Float64bits(float64(*m.`+fieldname, `))`)
-			}
+		if packed {
+			p.encodeKey(fieldNumber, wireType)
+			p.callVarint(`len(m.`, fieldname, `) * 8`)
+			p.P(`for _, num := range m.`, fieldname, ` {`)
+			p.In()
+			p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float64bits(float64(num))`)
+			p.callFixed64("f" + numGen.Current())
+			p.Out()
+			p.P(`}`)
+		} else if repeated {
+			p.P(`for _, num := range m.`, fieldname, ` {`)
+			p.In()
+			p.encodeKey(fieldNumber, wireType)
+			p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float64bits(float64(num))`)
+			p.callFixed64("f" + numGen.Current())
+			p.Out()
+			p.P(`}`)
+		} else if proto3 {
+			p.P(`if m.`, fieldname, ` != 0 {`)
+			p.In()
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed64(p.mathPkg.Use(), `.Float64bits(float64(m.`+fieldname, `))`)
+			p.Out()
+			p.P(`}`)
+		} else if !nullable {
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed64(p.mathPkg.Use(), `.Float64bits(float64(m.`+fieldname, `))`)
 		} else {
-			if packed {
-				p.encodeKey(fieldNumber, wireType)
-				p.callVarint(`len(m.`, fieldname, `) * 8`)
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.unsafeFixed64("num", "float64")
-				p.Out()
-				p.P(`}`)
-			} else if repeated {
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed64("num", "float64")
-				p.Out()
-				p.P(`}`)
-			} else if proto3 {
-				p.P(`if m.`, fieldname, ` != 0 {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed64(`m.`+fieldname, "float64")
-				p.Out()
-				p.P(`}`)
-			} else if !nullable {
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed64(`m.`+fieldname, "float64")
-			} else {
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed64(`*m.`+fieldname, `float64`)
-			}
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed64(p.mathPkg.Use(), `.Float64bits(float64(*m.`+fieldname, `))`)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_FLOAT:
-		if !p.unsafe || gogoproto.IsCastType(field) {
-			if packed {
-				p.encodeKey(fieldNumber, wireType)
-				p.callVarint(`len(m.`, fieldname, `) * 4`)
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float32bits(float32(num))`)
-				p.encodeFixed32("f" + numGen.Current())
-				p.Out()
-				p.P(`}`)
-			} else if repeated {
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float32bits(float32(num))`)
-				p.encodeFixed32("f" + numGen.Current())
-				p.Out()
-				p.P(`}`)
-			} else if proto3 {
-				p.P(`if m.`, fieldname, ` != 0 {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed32(p.mathPkg.Use(), `.Float32bits(float32(m.`+fieldname, `))`)
-				p.Out()
-				p.P(`}`)
-			} else if !nullable {
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed32(p.mathPkg.Use(), `.Float32bits(float32(m.`+fieldname, `))`)
-			} else {
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed32(p.mathPkg.Use(), `.Float32bits(float32(*m.`+fieldname, `))`)
-			}
+		if packed {
+			p.encodeKey(fieldNumber, wireType)
+			p.callVarint(`len(m.`, fieldname, `) * 4`)
+			p.P(`for _, num := range m.`, fieldname, ` {`)
+			p.In()
+			p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float32bits(float32(num))`)
+			p.callFixed32("f" + numGen.Current())
+			p.Out()
+			p.P(`}`)
+		} else if repeated {
+			p.P(`for _, num := range m.`, fieldname, ` {`)
+			p.In()
+			p.encodeKey(fieldNumber, wireType)
+			p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float32bits(float32(num))`)
+			p.callFixed32("f" + numGen.Current())
+			p.Out()
+			p.P(`}`)
+		} else if proto3 {
+			p.P(`if m.`, fieldname, ` != 0 {`)
+			p.In()
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed32(p.mathPkg.Use(), `.Float32bits(float32(m.`+fieldname, `))`)
+			p.Out()
+			p.P(`}`)
+		} else if !nullable {
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed32(p.mathPkg.Use(), `.Float32bits(float32(m.`+fieldname, `))`)
 		} else {
-			if packed {
-				p.encodeKey(fieldNumber, wireType)
-				p.callVarint(`len(m.`, fieldname, `) * 4`)
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.unsafeFixed32("num", "float32")
-				p.Out()
-				p.P(`}`)
-			} else if repeated {
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed32("num", "float32")
-				p.Out()
-				p.P(`}`)
-			} else if proto3 {
-				p.P(`if m.`, fieldname, ` != 0 {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed32(`m.`+fieldname, `float32`)
-				p.Out()
-				p.P(`}`)
-			} else if !nullable {
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed32(`m.`+fieldname, `float32`)
-			} else {
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed32(`*m.`+fieldname, "float32")
-			}
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed32(p.mathPkg.Use(), `.Float32bits(float32(*m.`+fieldname, `))`)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_INT64,
 		descriptor.FieldDescriptorProto_TYPE_UINT64,
@@ -610,137 +500,65 @@ func (p *marshalto) generateField(proto3 bool, numGen NumGen, file *generator.Fi
 		}
 	case descriptor.FieldDescriptorProto_TYPE_FIXED64,
 		descriptor.FieldDescriptorProto_TYPE_SFIXED64:
-		if !p.unsafe {
-			if packed {
-				p.encodeKey(fieldNumber, wireType)
-				p.callVarint(`len(m.`, fieldname, `) * 8`)
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.encodeFixed64("num")
-				p.Out()
-				p.P(`}`)
-			} else if repeated {
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.encodeFixed64("num")
-				p.Out()
-				p.P(`}`)
-			} else if proto3 {
-				p.P(`if m.`, fieldname, ` != 0 {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed64("m." + fieldname)
-				p.Out()
-				p.P(`}`)
-			} else if !nullable {
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed64("m." + fieldname)
-			} else {
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed64("*m." + fieldname)
-			}
+		if packed {
+			p.encodeKey(fieldNumber, wireType)
+			p.callVarint(`len(m.`, fieldname, `) * 8`)
+			p.P(`for _, num := range m.`, fieldname, ` {`)
+			p.In()
+			p.callFixed64("num")
+			p.Out()
+			p.P(`}`)
+		} else if repeated {
+			p.P(`for _, num := range m.`, fieldname, ` {`)
+			p.In()
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed64("num")
+			p.Out()
+			p.P(`}`)
+		} else if proto3 {
+			p.P(`if m.`, fieldname, ` != 0 {`)
+			p.In()
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed64("m." + fieldname)
+			p.Out()
+			p.P(`}`)
+		} else if !nullable {
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed64("m." + fieldname)
 		} else {
-			typeName := "int64"
-			if *field.Type == descriptor.FieldDescriptorProto_TYPE_FIXED64 {
-				typeName = "uint64"
-			}
-			if packed {
-				p.encodeKey(fieldNumber, wireType)
-				p.callVarint(`len(m.`, fieldname, `) * 8`)
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.unsafeFixed64("num", typeName)
-				p.Out()
-				p.P(`}`)
-			} else if repeated {
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed64("num", typeName)
-				p.Out()
-				p.P(`}`)
-			} else if proto3 {
-				p.P(`if m.`, fieldname, ` != 0 {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed64("m."+fieldname, typeName)
-				p.Out()
-				p.P(`}`)
-			} else if !nullable {
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed64("m."+fieldname, typeName)
-			} else {
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed64("*m."+fieldname, typeName)
-			}
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed64("*m." + fieldname)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_FIXED32,
 		descriptor.FieldDescriptorProto_TYPE_SFIXED32:
-		if !p.unsafe {
-			if packed {
-				p.encodeKey(fieldNumber, wireType)
-				p.callVarint(`len(m.`, fieldname, `) * 4`)
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.encodeFixed32("num")
-				p.Out()
-				p.P(`}`)
-			} else if repeated {
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.encodeFixed32("num")
-				p.Out()
-				p.P(`}`)
-			} else if proto3 {
-				p.P(`if m.`, fieldname, ` != 0 {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed32("m." + fieldname)
-				p.Out()
-				p.P(`}`)
-			} else if !nullable {
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed32("m." + fieldname)
-			} else {
-				p.encodeKey(fieldNumber, wireType)
-				p.callFixed32("*m." + fieldname)
-			}
+		if packed {
+			p.encodeKey(fieldNumber, wireType)
+			p.callVarint(`len(m.`, fieldname, `) * 4`)
+			p.P(`for _, num := range m.`, fieldname, ` {`)
+			p.In()
+			p.callFixed32("num")
+			p.Out()
+			p.P(`}`)
+		} else if repeated {
+			p.P(`for _, num := range m.`, fieldname, ` {`)
+			p.In()
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed32("num")
+			p.Out()
+			p.P(`}`)
+		} else if proto3 {
+			p.P(`if m.`, fieldname, ` != 0 {`)
+			p.In()
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed32("m." + fieldname)
+			p.Out()
+			p.P(`}`)
+		} else if !nullable {
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed32("m." + fieldname)
 		} else {
-			typeName := "int32"
-			if *field.Type == descriptor.FieldDescriptorProto_TYPE_FIXED32 {
-				typeName = "uint32"
-			}
-			if packed {
-				p.encodeKey(fieldNumber, wireType)
-				p.callVarint(`len(m.`, fieldname, `) * 4`)
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.unsafeFixed32("num", typeName)
-				p.Out()
-				p.P(`}`)
-			} else if repeated {
-				p.P(`for _, num := range m.`, fieldname, ` {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed32("num", typeName)
-				p.Out()
-				p.P(`}`)
-			} else if proto3 {
-				p.P(`if m.`, fieldname, ` != 0 {`)
-				p.In()
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed32("m."+fieldname, typeName)
-				p.Out()
-				p.P(`}`)
-			} else if !nullable {
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed32("m."+fieldname, typeName)
-			} else {
-				p.encodeKey(fieldNumber, wireType)
-				p.unsafeFixed32("*m."+fieldname, typeName)
-			}
+			p.encodeKey(fieldNumber, wireType)
+			p.callFixed32("*m." + fieldname)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_BOOL:
 		if packed {
@@ -1240,6 +1058,7 @@ func (p *marshalto) generateField(proto3 bool, numGen NumGen, file *generator.Fi
 func (p *marshalto) Generate(file *generator.FileDescriptor) {
 	numGen := NewNumGen()
 	p.PluginImports = generator.NewPluginImports(p.Generator)
+
 	p.atleastOne = false
 	p.localName = generator.FileName(file)
 
@@ -1249,8 +1068,8 @@ func (p *marshalto) Generate(file *generator.FileDescriptor) {
 	if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) {
 		p.protoPkg = p.NewImport("github.com/golang/protobuf/proto")
 	}
-	p.unsafePkg = p.NewImport("unsafe")
 	p.errorsPkg = p.NewImport("errors")
+	p.binaryPkg = p.NewImport("encoding/binary")
 	p.typesPkg = p.NewImport("github.com/gogo/protobuf/types")
 
 	for _, message := range file.Messages() {
@@ -1258,21 +1077,9 @@ func (p *marshalto) Generate(file *generator.FileDescriptor) {
 			continue
 		}
 		ccTypeName := generator.CamelCaseSlice(message.TypeName())
-		if p.unsafe {
-			if !gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) {
-				continue
-			}
-			if gogoproto.IsMarshaler(file.FileDescriptorProto, message.DescriptorProto) {
-				panic(fmt.Sprintf("unsafe_marshaler and marshalto enabled for %v", ccTypeName))
-			}
-		}
-		if !p.unsafe {
-			if !gogoproto.IsMarshaler(file.FileDescriptorProto, message.DescriptorProto) {
-				continue
-			}
-			if gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) {
-				panic(fmt.Sprintf("unsafe_marshaler and marshalto enabled for %v", ccTypeName))
-			}
+		if !gogoproto.IsMarshaler(file.FileDescriptorProto, message.DescriptorProto) &&
+			!gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) {
+			continue
 		}
 		p.atleastOne = true
 
@@ -1367,7 +1174,7 @@ func (p *marshalto) Generate(file *generator.FileDescriptor) {
 			p.P(`func (m *`, ccTypeName, `) MarshalTo(dAtA []byte) (int, error) {`)
 			p.In()
 			p.P(`i := 0`)
-			vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly(field)
+			vanity.TurnOffNullableForNativeTypes(field)
 			p.generateField(false, numGen, file, message, field)
 			p.P(`return i, nil`)
 			p.Out()
@@ -1376,30 +1183,6 @@ func (p *marshalto) Generate(file *generator.FileDescriptor) {
 	}
 
 	if p.atleastOne {
-		p.P(`func encodeFixed64`, p.localName, `(dAtA []byte, offset int, v uint64) int {`)
-		p.In()
-		p.P(`dAtA[offset] = uint8(v)`)
-		p.P(`dAtA[offset+1] = uint8(v >> 8)`)
-		p.P(`dAtA[offset+2] = uint8(v >> 16)`)
-		p.P(`dAtA[offset+3] = uint8(v >> 24)`)
-		p.P(`dAtA[offset+4] = uint8(v >> 32)`)
-		p.P(`dAtA[offset+5] = uint8(v >> 40)`)
-		p.P(`dAtA[offset+6] = uint8(v >> 48)`)
-		p.P(`dAtA[offset+7] = uint8(v >> 56)`)
-		p.P(`return offset+8`)
-		p.Out()
-		p.P(`}`)
-
-		p.P(`func encodeFixed32`, p.localName, `(dAtA []byte, offset int, v uint32) int {`)
-		p.In()
-		p.P(`dAtA[offset] = uint8(v)`)
-		p.P(`dAtA[offset+1] = uint8(v >> 8)`)
-		p.P(`dAtA[offset+2] = uint8(v >> 16)`)
-		p.P(`dAtA[offset+3] = uint8(v >> 24)`)
-		p.P(`return offset+4`)
-		p.Out()
-		p.P(`}`)
-
 		p.P(`func encodeVarint`, p.localName, `(dAtA []byte, offset int, v uint64) int {`)
 		p.In()
 		p.P(`for v >= 1<<7 {`)
@@ -1419,5 +1202,4 @@ func (p *marshalto) Generate(file *generator.FileDescriptor) {
 
 func init() {
 	generator.RegisterPlugin(NewMarshal())
-	generator.RegisterPlugin(NewUnsafeMarshal())
 }
diff --git a/vendor/github.com/gogo/protobuf/plugin/populate/populate.go b/vendor/github.com/gogo/protobuf/plugin/populate/populate.go
index 16aee324898..30e5a69e2d5 100644
--- a/vendor/github.com/gogo/protobuf/plugin/populate/populate.go
+++ b/vendor/github.com/gogo/protobuf/plugin/populate/populate.go
@@ -667,7 +667,7 @@ func (p *plugin) Generate(file *generator.FileDescriptor) {
 			p.P(`func NewPopulated`, ccTypeName, `(r randy`, p.localName, `, easy bool) *`, ccTypeName, ` {`)
 			p.In()
 			p.P(`this := &`, ccTypeName, `{}`)
-			vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly(f)
+			vanity.TurnOffNullableForNativeTypes(f)
 			p.GenerateField(file, message, f)
 			p.P(`return this`)
 			p.Out()
diff --git a/vendor/github.com/gogo/protobuf/plugin/size/size.go b/vendor/github.com/gogo/protobuf/plugin/size/size.go
index 014831b127c..79cd403be15 100644
--- a/vendor/github.com/gogo/protobuf/plugin/size/size.go
+++ b/vendor/github.com/gogo/protobuf/plugin/size/size.go
@@ -652,7 +652,7 @@ func (p *size) Generate(file *generator.FileDescriptor) {
 			p.In()
 			p.P(`var l int`)
 			p.P(`_ = l`)
-			vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly(f)
+			vanity.TurnOffNullableForNativeTypes(f)
 			p.generateField(false, file, message, f, sizeName)
 			p.P(`return n`)
 			p.Out()
diff --git a/vendor/github.com/gogo/protobuf/plugin/testgen/testgen.go b/vendor/github.com/gogo/protobuf/plugin/testgen/testgen.go
index a9364f99ad2..e0a9287e560 100644
--- a/vendor/github.com/gogo/protobuf/plugin/testgen/testgen.go
+++ b/vendor/github.com/gogo/protobuf/plugin/testgen/testgen.go
@@ -270,7 +270,6 @@ func (p *testProto) Generate(imports generator.PluginImports, file *generator.Fi
 	testingPkg := imports.NewImport("testing")
 	randPkg := imports.NewImport("math/rand")
 	timePkg := imports.NewImport("time")
-	unsafePkg := imports.NewImport("unsafe")
 	protoPkg := imports.NewImport("github.com/gogo/protobuf/proto")
 	if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) {
 		protoPkg = imports.NewImport("github.com/golang/protobuf/proto")
@@ -280,21 +279,11 @@ func (p *testProto) Generate(imports generator.PluginImports, file *generator.Fi
 		if message.DescriptorProto.GetOptions().GetMapEntry() {
 			continue
 		}
-		hasUnsafe := gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) ||
-			gogoproto.IsUnsafeUnmarshaler(file.FileDescriptorProto, message.DescriptorProto)
 		if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) {
 			used = true
 
 			p.P(`func Test`, ccTypeName, `Proto(t *`, testingPkg.Use(), `.T) {`)
 			p.In()
-			if hasUnsafe {
-				p.P(`var bigendian uint32 = 0x01020304`)
-				p.P(`if *(*byte)(`, unsafePkg.Use(), `.Pointer(&bigendian)) == 1 {`)
-				p.In()
-				p.P(`t.Skip("unsafe does not work on big endian architectures")`)
-				p.Out()
-				p.P(`}`)
-			}
 			p.P(`seed := `, timePkg.Use(), `.Now().UnixNano()`)
 			p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(seed))`)
 			p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`)
@@ -351,14 +340,6 @@ func (p *testProto) Generate(imports generator.PluginImports, file *generator.Fi
 			if gogoproto.IsMarshaler(file.FileDescriptorProto, message.DescriptorProto) || gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) {
 				p.P(`func Test`, ccTypeName, `MarshalTo(t *`, testingPkg.Use(), `.T) {`)
 				p.In()
-				if hasUnsafe {
-					p.P(`var bigendian uint32 = 0x01020304`)
-					p.P(`if *(*byte)(`, unsafePkg.Use(), `.Pointer(&bigendian)) == 1 {`)
-					p.In()
-					p.P(`t.Skip("unsafe does not work on big endian architectures")`)
-					p.Out()
-					p.P(`}`)
-				}
 				p.P(`seed := `, timePkg.Use(), `.Now().UnixNano()`)
 				p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(seed))`)
 				p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`)
diff --git a/vendor/github.com/gogo/protobuf/plugin/unmarshal/unmarshal.go b/vendor/github.com/gogo/protobuf/plugin/unmarshal/unmarshal.go
index 6b67914b0be..b5d9613df1d 100644
--- a/vendor/github.com/gogo/protobuf/plugin/unmarshal/unmarshal.go
+++ b/vendor/github.com/gogo/protobuf/plugin/unmarshal/unmarshal.go
@@ -187,13 +187,12 @@ import (
 
 type unmarshal struct {
 	*generator.Generator
-	unsafe bool
 	generator.PluginImports
 	atleastOne bool
 	ioPkg      generator.Single
 	mathPkg    generator.Single
-	unsafePkg  generator.Single
 	typesPkg   generator.Single
+	binaryPkg  generator.Single
 	localName  string
 }
 
@@ -201,14 +200,7 @@ func NewUnmarshal() *unmarshal {
 	return &unmarshal{}
 }
 
-func NewUnsafeUnmarshal() *unmarshal {
-	return &unmarshal{unsafe: true}
-}
-
 func (p *unmarshal) Name() string {
-	if p.unsafe {
-		return "unsafeunmarshaler"
-	}
 	return "unmarshal"
 }
 
@@ -247,20 +239,7 @@ func (p *unmarshal) decodeFixed32(varName string, typeName string) {
 	p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`)
 	p.Out()
 	p.P(`}`)
-	p.P(`iNdEx += 4`)
-	p.P(varName, ` = `, typeName, `(dAtA[iNdEx-4])`)
-	p.P(varName, ` |= `, typeName, `(dAtA[iNdEx-3]) << 8`)
-	p.P(varName, ` |= `, typeName, `(dAtA[iNdEx-2]) << 16`)
-	p.P(varName, ` |= `, typeName, `(dAtA[iNdEx-1]) << 24`)
-}
-
-func (p *unmarshal) unsafeFixed32(varName string, typeName string) {
-	p.P(`if iNdEx + 4 > l {`)
-	p.In()
-	p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`)
-	p.Out()
-	p.P(`}`)
-	p.P(varName, ` = *(*`, typeName, `)(`, p.unsafePkg.Use(), `.Pointer(&dAtA[iNdEx]))`)
+	p.P(varName, ` = `, typeName, `(`, p.binaryPkg.Use(), `.LittleEndian.Uint32(dAtA[iNdEx:]))`)
 	p.P(`iNdEx += 4`)
 }
 
@@ -270,25 +249,71 @@ func (p *unmarshal) decodeFixed64(varName string, typeName string) {
 	p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`)
 	p.Out()
 	p.P(`}`)
+	p.P(varName, ` = `, typeName, `(`, p.binaryPkg.Use(), `.LittleEndian.Uint64(dAtA[iNdEx:]))`)
 	p.P(`iNdEx += 8`)
-	p.P(varName, ` = `, typeName, `(dAtA[iNdEx-8])`)
-	p.P(varName, ` |= `, typeName, `(dAtA[iNdEx-7]) << 8`)
-	p.P(varName, ` |= `, typeName, `(dAtA[iNdEx-6]) << 16`)
-	p.P(varName, ` |= `, typeName, `(dAtA[iNdEx-5]) << 24`)
-	p.P(varName, ` |= `, typeName, `(dAtA[iNdEx-4]) << 32`)
-	p.P(varName, ` |= `, typeName, `(dAtA[iNdEx-3]) << 40`)
-	p.P(varName, ` |= `, typeName, `(dAtA[iNdEx-2]) << 48`)
-	p.P(varName, ` |= `, typeName, `(dAtA[iNdEx-1]) << 56`)
 }
 
-func (p *unmarshal) unsafeFixed64(varName string, typeName string) {
-	p.P(`if iNdEx + 8 > l {`)
-	p.In()
-	p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`)
-	p.Out()
-	p.P(`}`)
-	p.P(varName, ` = *(*`, typeName, `)(`, p.unsafePkg.Use(), `.Pointer(&dAtA[iNdEx]))`)
-	p.P(`iNdEx += 8`)
+func (p *unmarshal) declareMapField(varName string, nullable bool, customType bool, field *descriptor.FieldDescriptorProto) {
+	switch field.GetType() {
+	case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
+		p.P(`var `, varName, ` float64`)
+	case descriptor.FieldDescriptorProto_TYPE_FLOAT:
+		p.P(`var `, varName, ` float32`)
+	case descriptor.FieldDescriptorProto_TYPE_INT64:
+		p.P(`var `, varName, ` int64`)
+	case descriptor.FieldDescriptorProto_TYPE_UINT64:
+		p.P(`var `, varName, ` uint64`)
+	case descriptor.FieldDescriptorProto_TYPE_INT32:
+		p.P(`var `, varName, ` int32`)
+	case descriptor.FieldDescriptorProto_TYPE_FIXED64:
+		p.P(`var `, varName, ` uint64`)
+	case descriptor.FieldDescriptorProto_TYPE_FIXED32:
+		p.P(`var `, varName, ` uint32`)
+	case descriptor.FieldDescriptorProto_TYPE_BOOL:
+		p.P(`var `, varName, ` bool`)
+	case descriptor.FieldDescriptorProto_TYPE_STRING:
+		cast, _ := p.GoType(nil, field)
+		cast = strings.Replace(cast, "*", "", 1)
+		p.P(`var `, varName, ` `, cast)
+	case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
+		if gogoproto.IsStdTime(field) {
+			p.P(varName, ` := new(time.Time)`)
+		} else if gogoproto.IsStdDuration(field) {
+			p.P(varName, ` := new(time.Duration)`)
+		} else {
+			desc := p.ObjectNamed(field.GetTypeName())
+			msgname := p.TypeName(desc)
+			if nullable {
+				p.P(`var `, varName, ` *`, msgname)
+			} else {
+				p.P(varName, ` := &`, msgname, `{}`)
+			}
+		}
+	case descriptor.FieldDescriptorProto_TYPE_BYTES:
+		if customType {
+			_, ctyp, err := generator.GetCustomType(field)
+			if err != nil {
+				panic(err)
+			}
+			p.P(`var `, varName, `1 `, ctyp)
+			p.P(`var `, varName, ` = &`, varName, `1`)
+		} else {
+			p.P(varName, ` := []byte{}`)
+		}
+	case descriptor.FieldDescriptorProto_TYPE_UINT32:
+		p.P(`var `, varName, ` uint32`)
+	case descriptor.FieldDescriptorProto_TYPE_ENUM:
+		typName := p.TypeName(p.ObjectNamed(field.GetTypeName()))
+		p.P(`var `, varName, ` `, typName)
+	case descriptor.FieldDescriptorProto_TYPE_SFIXED32:
+		p.P(`var `, varName, ` int32`)
+	case descriptor.FieldDescriptorProto_TYPE_SFIXED64:
+		p.P(`var `, varName, ` int64`)
+	case descriptor.FieldDescriptorProto_TYPE_SINT32:
+		p.P(`var `, varName, ` int32`)
+	case descriptor.FieldDescriptorProto_TYPE_SINT64:
+		p.P(`var `, varName, ` int64`)
+	}
 }
 
 func (p *unmarshal) mapField(varName string, customType bool, field *descriptor.FieldDescriptorProto) {
@@ -296,30 +321,25 @@ func (p *unmarshal) mapField(varName string, customType bool, field *descriptor.
 	case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
 		p.P(`var `, varName, `temp uint64`)
 		p.decodeFixed64(varName+"temp", "uint64")
-		p.P(varName, ` := `, p.mathPkg.Use(), `.Float64frombits(`, varName, `temp)`)
+		p.P(varName, ` = `, p.mathPkg.Use(), `.Float64frombits(`, varName, `temp)`)
 	case descriptor.FieldDescriptorProto_TYPE_FLOAT:
 		p.P(`var `, varName, `temp uint32`)
 		p.decodeFixed32(varName+"temp", "uint32")
-		p.P(varName, ` := `, p.mathPkg.Use(), `.Float32frombits(`, varName, `temp)`)
+		p.P(varName, ` = `, p.mathPkg.Use(), `.Float32frombits(`, varName, `temp)`)
 	case descriptor.FieldDescriptorProto_TYPE_INT64:
-		p.P(`var `, varName, ` int64`)
 		p.decodeVarint(varName, "int64")
 	case descriptor.FieldDescriptorProto_TYPE_UINT64:
-		p.P(`var `, varName, ` uint64`)
 		p.decodeVarint(varName, "uint64")
 	case descriptor.FieldDescriptorProto_TYPE_INT32:
-		p.P(`var `, varName, ` int32`)
 		p.decodeVarint(varName, "int32")
 	case descriptor.FieldDescriptorProto_TYPE_FIXED64:
-		p.P(`var `, varName, ` uint64`)
 		p.decodeFixed64(varName, "uint64")
 	case descriptor.FieldDescriptorProto_TYPE_FIXED32:
-		p.P(`var `, varName, ` uint32`)
 		p.decodeFixed32(varName, "uint32")
 	case descriptor.FieldDescriptorProto_TYPE_BOOL:
 		p.P(`var `, varName, `temp int`)
 		p.decodeVarint(varName+"temp", "int")
-		p.P(varName, ` := bool(`, varName, `temp != 0)`)
+		p.P(varName, ` = bool(`, varName, `temp != 0)`)
 	case descriptor.FieldDescriptorProto_TYPE_STRING:
 		p.P(`var stringLen`, varName, ` uint64`)
 		p.decodeVarint("stringLen"+varName, "uint64")
@@ -337,7 +357,7 @@ func (p *unmarshal) mapField(varName string, customType bool, field *descriptor.
 		p.P(`}`)
 		cast, _ := p.GoType(nil, field)
 		cast = strings.Replace(cast, "*", "", 1)
-		p.P(varName, ` := `, cast, `(dAtA[iNdEx:postStringIndex`, varName, `])`)
+		p.P(varName, ` = `, cast, `(dAtA[iNdEx:postStringIndex`, varName, `])`)
 		p.P(`iNdEx = postStringIndex`, varName)
 	case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
 		p.P(`var mapmsglen int`)
@@ -358,17 +378,15 @@ func (p *unmarshal) mapField(varName string, customType bool, field *descriptor.
 		p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`)
 		p.Out()
 		p.P(`}`)
-		desc := p.ObjectNamed(field.GetTypeName())
-		msgname := p.TypeName(desc)
 		buf := `dAtA[iNdEx:postmsgIndex]`
 		if gogoproto.IsStdTime(field) {
-			p.P(varName, ` := new(time.Time)`)
 			p.P(`if err := `, p.typesPkg.Use(), `.StdTimeUnmarshal(`, varName, `, `, buf, `); err != nil {`)
 		} else if gogoproto.IsStdDuration(field) {
-			p.P(varName, ` := new(time.Duration)`)
 			p.P(`if err := `, p.typesPkg.Use(), `.StdDurationUnmarshal(`, varName, `, `, buf, `); err != nil {`)
 		} else {
-			p.P(varName, ` := &`, msgname, `{}`)
+			desc := p.ObjectNamed(field.GetTypeName())
+			msgname := p.TypeName(desc)
+			p.P(varName, ` = &`, msgname, `{}`)
 			p.P(`if err := `, varName, `.Unmarshal(`, buf, `); err != nil {`)
 		}
 		p.In()
@@ -392,45 +410,35 @@ func (p *unmarshal) mapField(varName string, customType bool, field *descriptor.
 		p.Out()
 		p.P(`}`)
 		if customType {
-			_, ctyp, err := generator.GetCustomType(field)
-			if err != nil {
-				panic(err)
-			}
-			p.P(`var `, varName, `1 `, ctyp)
-			p.P(`var `, varName, ` = &`, varName, `1`)
 			p.P(`if err := `, varName, `.Unmarshal(dAtA[iNdEx:postbytesIndex]); err != nil {`)
 			p.In()
 			p.P(`return err`)
 			p.Out()
 			p.P(`}`)
 		} else {
-			p.P(varName, ` := make([]byte, mapbyteLen)`)
+			p.P(varName, ` = make([]byte, mapbyteLen)`)
 			p.P(`copy(`, varName, `, dAtA[iNdEx:postbytesIndex])`)
 		}
 		p.P(`iNdEx = postbytesIndex`)
 	case descriptor.FieldDescriptorProto_TYPE_UINT32:
-		p.P(`var `, varName, ` uint32`)
 		p.decodeVarint(varName, "uint32")
 	case descriptor.FieldDescriptorProto_TYPE_ENUM:
 		typName := p.TypeName(p.ObjectNamed(field.GetTypeName()))
-		p.P(`var `, varName, ` `, typName)
 		p.decodeVarint(varName, typName)
 	case descriptor.FieldDescriptorProto_TYPE_SFIXED32:
-		p.P(`var `, varName, ` int32`)
 		p.decodeFixed32(varName, "int32")
 	case descriptor.FieldDescriptorProto_TYPE_SFIXED64:
-		p.P(`var `, varName, ` int64`)
 		p.decodeFixed64(varName, "int64")
 	case descriptor.FieldDescriptorProto_TYPE_SINT32:
 		p.P(`var `, varName, `temp int32`)
 		p.decodeVarint(varName+"temp", "int32")
 		p.P(varName, `temp = int32((uint32(`, varName, `temp) >> 1) ^ uint32(((`, varName, `temp&1)<<31)>>31))`)
-		p.P(varName, ` := int32(`, varName, `temp)`)
+		p.P(varName, ` = int32(`, varName, `temp)`)
 	case descriptor.FieldDescriptorProto_TYPE_SINT64:
 		p.P(`var `, varName, `temp uint64`)
 		p.decodeVarint(varName+"temp", "uint64")
 		p.P(varName, `temp = (`, varName, `temp >> 1) ^ uint64((int64(`, varName, `temp&1)<<63)>>63)`)
-		p.P(varName, ` := int64(`, varName, `temp)`)
+		p.P(varName, ` = int64(`, varName, `temp)`)
 	}
 }
 
@@ -452,68 +460,32 @@ func (p *unmarshal) field(file *generator.FileDescriptor, msg *generator.Descrip
 	oneof := field.OneofIndex != nil
 	switch *field.Type {
 	case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
-		if !p.unsafe || gogoproto.IsCastType(field) {
-			p.P(`var v uint64`)
-			p.decodeFixed64("v", "uint64")
-			if oneof {
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{`, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))}`)
-			} else if repeated {
-				p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))`)
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v2)`)
-			} else if proto3 || !nullable {
-				p.P(`m.`, fieldname, ` = `, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))`)
-			} else {
-				p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))`)
-				p.P(`m.`, fieldname, ` = &v2`)
-			}
+		p.P(`var v uint64`)
+		p.decodeFixed64("v", "uint64")
+		if oneof {
+			p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{`, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))}`)
+		} else if repeated {
+			p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))`)
+			p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v2)`)
+		} else if proto3 || !nullable {
+			p.P(`m.`, fieldname, ` = `, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))`)
 		} else {
-			if oneof {
-				p.P(`var v float64`)
-				p.unsafeFixed64("v", "float64")
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
-			} else if repeated {
-				p.P(`var v float64`)
-				p.unsafeFixed64("v", "float64")
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
-			} else if proto3 || !nullable {
-				p.unsafeFixed64(`m.`+fieldname, "float64")
-			} else {
-				p.P(`var v float64`)
-				p.unsafeFixed64("v", "float64")
-				p.P(`m.`, fieldname, ` = &v`)
-			}
+			p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))`)
+			p.P(`m.`, fieldname, ` = &v2`)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_FLOAT:
-		if !p.unsafe || gogoproto.IsCastType(field) {
-			p.P(`var v uint32`)
-			p.decodeFixed32("v", "uint32")
-			if oneof {
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{`, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))}`)
-			} else if repeated {
-				p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))`)
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v2)`)
-			} else if proto3 || !nullable {
-				p.P(`m.`, fieldname, ` = `, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))`)
-			} else {
-				p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))`)
-				p.P(`m.`, fieldname, ` = &v2`)
-			}
+		p.P(`var v uint32`)
+		p.decodeFixed32("v", "uint32")
+		if oneof {
+			p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{`, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))}`)
+		} else if repeated {
+			p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))`)
+			p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v2)`)
+		} else if proto3 || !nullable {
+			p.P(`m.`, fieldname, ` = `, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))`)
 		} else {
-			if oneof {
-				p.P(`var v float32`)
-				p.unsafeFixed32("v", "float32")
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
-			} else if repeated {
-				p.P(`var v float32`)
-				p.unsafeFixed32("v", "float32")
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
-			} else if proto3 || !nullable {
-				p.unsafeFixed32("m."+fieldname, "float32")
-			} else {
-				p.P(`var v float32`)
-				p.unsafeFixed32("v", "float32")
-				p.P(`m.`, fieldname, ` = &v`)
-			}
+			p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))`)
+			p.P(`m.`, fieldname, ` = &v2`)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_INT64:
 		if oneof {
@@ -567,74 +539,38 @@ func (p *unmarshal) field(file *generator.FileDescriptor, msg *generator.Descrip
 			p.P(`m.`, fieldname, ` = &v`)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_FIXED64:
-		if !p.unsafe || gogoproto.IsCastType(field) {
-			if oneof {
-				p.P(`var v `, typ)
-				p.decodeFixed64("v", typ)
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
-			} else if repeated {
-				p.P(`var v `, typ)
-				p.decodeFixed64("v", typ)
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
-			} else if proto3 || !nullable {
-				p.P(`m.`, fieldname, ` = 0`)
-				p.decodeFixed64("m."+fieldname, typ)
-			} else {
-				p.P(`var v `, typ)
-				p.decodeFixed64("v", typ)
-				p.P(`m.`, fieldname, ` = &v`)
-			}
+		if oneof {
+			p.P(`var v `, typ)
+			p.decodeFixed64("v", typ)
+			p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
+		} else if repeated {
+			p.P(`var v `, typ)
+			p.decodeFixed64("v", typ)
+			p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
+		} else if proto3 || !nullable {
+			p.P(`m.`, fieldname, ` = 0`)
+			p.decodeFixed64("m."+fieldname, typ)
 		} else {
-			if oneof {
-				p.P(`var v uint64`)
-				p.unsafeFixed64("v", "uint64")
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
-			} else if repeated {
-				p.P(`var v uint64`)
-				p.unsafeFixed64("v", "uint64")
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
-			} else if proto3 || !nullable {
-				p.unsafeFixed64("m."+fieldname, "uint64")
-			} else {
-				p.P(`var v uint64`)
-				p.unsafeFixed64("v", "uint64")
-				p.P(`m.`, fieldname, ` = &v`)
-			}
+			p.P(`var v `, typ)
+			p.decodeFixed64("v", typ)
+			p.P(`m.`, fieldname, ` = &v`)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_FIXED32:
-		if !p.unsafe || gogoproto.IsCastType(field) {
-			if oneof {
-				p.P(`var v `, typ)
-				p.decodeFixed32("v", typ)
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
-			} else if repeated {
-				p.P(`var v `, typ)
-				p.decodeFixed32("v", typ)
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
-			} else if proto3 || !nullable {
-				p.P(`m.`, fieldname, ` = 0`)
-				p.decodeFixed32("m."+fieldname, typ)
-			} else {
-				p.P(`var v `, typ)
-				p.decodeFixed32("v", typ)
-				p.P(`m.`, fieldname, ` = &v`)
-			}
+		if oneof {
+			p.P(`var v `, typ)
+			p.decodeFixed32("v", typ)
+			p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
+		} else if repeated {
+			p.P(`var v `, typ)
+			p.decodeFixed32("v", typ)
+			p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
+		} else if proto3 || !nullable {
+			p.P(`m.`, fieldname, ` = 0`)
+			p.decodeFixed32("m."+fieldname, typ)
 		} else {
-			if oneof {
-				p.P(`var v uint32`)
-				p.unsafeFixed32("v", "uint32")
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
-			} else if repeated {
-				p.P(`var v uint32`)
-				p.unsafeFixed32("v", "uint32")
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
-			} else if proto3 || !nullable {
-				p.unsafeFixed32("m."+fieldname, "uint32")
-			} else {
-				p.P(`var v uint32`)
-				p.unsafeFixed32("v", "uint32")
-				p.P(`m.`, fieldname, ` = &v`)
-			}
+			p.P(`var v `, typ)
+			p.decodeFixed32("v", typ)
+			p.P(`m.`, fieldname, ` = &v`)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_BOOL:
 		p.P(`var v int`)
@@ -747,20 +683,63 @@ func (p *unmarshal) field(file *generator.FileDescriptor, msg *generator.Descrip
 				valuegoTyp = valuegoAliasTyp
 			}
 
-			p.P(`var keykey uint64`)
-			p.decodeVarint("keykey", "uint64")
-			p.mapField("mapkey", false, m.KeyAliasField)
 			p.P(`if m.`, fieldname, ` == nil {`)
 			p.In()
 			p.P(`m.`, fieldname, ` = make(`, m.GoType, `)`)
 			p.Out()
 			p.P(`}`)
+
+			p.declareMapField("mapkey", false, false, m.KeyAliasField)
+			p.declareMapField("mapvalue", nullable, gogoproto.IsCustomType(field), m.ValueAliasField)
+			p.P(`for iNdEx < postIndex {`)
+			p.In()
+
+			p.P(`entryPreIndex := iNdEx`)
+			p.P(`var wire uint64`)
+			p.decodeVarint("wire", "uint64")
+			p.P(`fieldNum := int32(wire >> 3)`)
+
+			p.P(`if fieldNum == 1 {`)
+			p.In()
+			p.mapField("mapkey", false, m.KeyAliasField)
+			p.Out()
+			p.P(`} else if fieldNum == 2 {`)
+			p.In()
+			p.mapField("mapvalue", gogoproto.IsCustomType(field), m.ValueAliasField)
+			p.Out()
+			p.P(`} else {`)
+			p.In()
+			p.P(`iNdEx = entryPreIndex`)
+			p.P(`skippy, err := skip`, p.localName, `(dAtA[iNdEx:])`)
+			p.P(`if err != nil {`)
+			p.In()
+			p.P(`return err`)
+			p.Out()
+			p.P(`}`)
+			p.P(`if skippy < 0 {`)
+			p.In()
+			p.P(`return ErrInvalidLength`, p.localName)
+			p.Out()
+			p.P(`}`)
+			p.P(`if (iNdEx + skippy) > postIndex {`)
+			p.In()
+			p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`)
+			p.Out()
+			p.P(`}`)
+			p.P(`iNdEx += skippy`)
+			p.Out()
+			p.P(`}`)
+
+			p.Out()
+			p.P(`}`)
+
 			s := `m.` + fieldname
 			if keygoTyp == keygoAliasTyp {
 				s += `[mapkey]`
 			} else {
 				s += `[` + keygoAliasTyp + `(mapkey)]`
 			}
+
 			v := `mapvalue`
 			if (m.ValueField.IsMessage() || gogoproto.IsCustomType(field)) && !nullable {
 				v = `*` + v
@@ -768,35 +747,8 @@ func (p *unmarshal) field(file *generator.FileDescriptor, msg *generator.Descrip
 			if valuegoTyp != valuegoAliasTyp {
 				v = `((` + valuegoAliasTyp + `)(` + v + `))`
 			}
-			p.P(`if iNdEx < postIndex {`)
-			p.In()
-			p.P(`var valuekey uint64`)
-			p.decodeVarint("valuekey", "uint64")
-			p.mapField("mapvalue", gogoproto.IsCustomType(field), m.ValueAliasField)
+
 			p.P(s, ` = `, v)
-			p.Out()
-			p.P(`} else {`)
-			p.In()
-			if gogoproto.IsStdTime(field) {
-				p.P(`var mapvalue = new(time.Time)`)
-				if nullable {
-					p.P(s, ` = mapvalue`)
-				} else {
-					p.P(s, ` = *mapvalue`)
-				}
-			} else if gogoproto.IsStdDuration(field) {
-				p.P(`var mapvalue = new(time.Duration)`)
-				if nullable {
-					p.P(s, ` = mapvalue`)
-				} else {
-					p.P(s, ` = *mapvalue`)
-				}
-			} else {
-				p.P(`var mapvalue `, valuegoAliasTyp)
-				p.P(s, ` = mapvalue`)
-			}
-			p.Out()
-			p.P(`}`)
 		} else if repeated {
 			if gogoproto.IsStdTime(field) {
 				if nullable {
@@ -984,74 +936,38 @@ func (p *unmarshal) field(file *generator.FileDescriptor, msg *generator.Descrip
 			p.P(`m.`, fieldname, ` = &v`)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_SFIXED32:
-		if !p.unsafe || gogoproto.IsCastType(field) {
-			if oneof {
-				p.P(`var v `, typ)
-				p.decodeFixed32("v", typ)
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
-			} else if repeated {
-				p.P(`var v `, typ)
-				p.decodeFixed32("v", typ)
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
-			} else if proto3 || !nullable {
-				p.P(`m.`, fieldname, ` = 0`)
-				p.decodeFixed32("m."+fieldname, typ)
-			} else {
-				p.P(`var v `, typ)
-				p.decodeFixed32("v", typ)
-				p.P(`m.`, fieldname, ` = &v`)
-			}
+		if oneof {
+			p.P(`var v `, typ)
+			p.decodeFixed32("v", typ)
+			p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
+		} else if repeated {
+			p.P(`var v `, typ)
+			p.decodeFixed32("v", typ)
+			p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
+		} else if proto3 || !nullable {
+			p.P(`m.`, fieldname, ` = 0`)
+			p.decodeFixed32("m."+fieldname, typ)
 		} else {
-			if oneof {
-				p.P(`var v int32`)
-				p.unsafeFixed32("v", "int32")
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
-			} else if repeated {
-				p.P(`var v int32`)
-				p.unsafeFixed32("v", "int32")
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
-			} else if proto3 || !nullable {
-				p.unsafeFixed32("m."+fieldname, "int32")
-			} else {
-				p.P(`var v int32`)
-				p.unsafeFixed32("v", "int32")
-				p.P(`m.`, fieldname, ` = &v`)
-			}
+			p.P(`var v `, typ)
+			p.decodeFixed32("v", typ)
+			p.P(`m.`, fieldname, ` = &v`)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_SFIXED64:
-		if !p.unsafe || gogoproto.IsCastType(field) {
-			if oneof {
-				p.P(`var v `, typ)
-				p.decodeFixed64("v", typ)
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
-			} else if repeated {
-				p.P(`var v `, typ)
-				p.decodeFixed64("v", typ)
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
-			} else if proto3 || !nullable {
-				p.P(`m.`, fieldname, ` = 0`)
-				p.decodeFixed64("m."+fieldname, typ)
-			} else {
-				p.P(`var v `, typ)
-				p.decodeFixed64("v", typ)
-				p.P(`m.`, fieldname, ` = &v`)
-			}
+		if oneof {
+			p.P(`var v `, typ)
+			p.decodeFixed64("v", typ)
+			p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
+		} else if repeated {
+			p.P(`var v `, typ)
+			p.decodeFixed64("v", typ)
+			p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
+		} else if proto3 || !nullable {
+			p.P(`m.`, fieldname, ` = 0`)
+			p.decodeFixed64("m."+fieldname, typ)
 		} else {
-			if oneof {
-				p.P(`var v int64`)
-				p.unsafeFixed64("v", "int64")
-				p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`)
-			} else if repeated {
-				p.P(`var v int64`)
-				p.unsafeFixed64("v", "int64")
-				p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`)
-			} else if proto3 || !nullable {
-				p.unsafeFixed64("m."+fieldname, "int64")
-			} else {
-				p.P(`var v int64`)
-				p.unsafeFixed64("v", "int64")
-				p.P(`m.`, fieldname, ` = &v`)
-			}
+			p.P(`var v `, typ)
+			p.decodeFixed64("v", typ)
+			p.P(`m.`, fieldname, ` = &v`)
 		}
 	case descriptor.FieldDescriptorProto_TYPE_SINT32:
 		p.P(`var v `, typ)
@@ -1090,14 +1006,11 @@ func (p *unmarshal) Generate(file *generator.FileDescriptor) {
 	p.PluginImports = generator.NewPluginImports(p.Generator)
 	p.atleastOne = false
 	p.localName = generator.FileName(file)
-	if p.unsafe {
-		p.localName += "Unsafe"
-	}
 
 	p.ioPkg = p.NewImport("io")
 	p.mathPkg = p.NewImport("math")
-	p.unsafePkg = p.NewImport("unsafe")
 	p.typesPkg = p.NewImport("github.com/gogo/protobuf/types")
+	p.binaryPkg = p.NewImport("encoding/binary")
 	fmtPkg := p.NewImport("fmt")
 	protoPkg := p.NewImport("github.com/gogo/protobuf/proto")
 	if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) {
@@ -1106,21 +1019,9 @@ func (p *unmarshal) Generate(file *generator.FileDescriptor) {
 
 	for _, message := range file.Messages() {
 		ccTypeName := generator.CamelCaseSlice(message.TypeName())
-		if p.unsafe {
-			if !gogoproto.IsUnsafeUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) {
-				continue
-			}
-			if gogoproto.IsUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) {
-				panic(fmt.Sprintf("unsafe_unmarshaler and unmarshaler enabled for %v", ccTypeName))
-			}
-		}
-		if !p.unsafe {
-			if !gogoproto.IsUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) {
-				continue
-			}
-			if gogoproto.IsUnsafeUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) {
-				panic(fmt.Sprintf("unsafe_unmarshaler and unmarshaler enabled for %v", ccTypeName))
-			}
+		if !gogoproto.IsUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) &&
+			!gogoproto.IsUnsafeUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) {
+			continue
 		}
 		if message.DescriptorProto.GetOptions().GetMapEntry() {
 			continue
@@ -1445,5 +1346,4 @@ func (p *unmarshal) Generate(file *generator.FileDescriptor) {
 
 func init() {
 	generator.RegisterPlugin(NewUnmarshal())
-	generator.RegisterPlugin(NewUnsafeUnmarshal())
 }
diff --git a/vendor/github.com/gogo/protobuf/proto/encode.go b/vendor/github.com/gogo/protobuf/proto/encode.go
index 2b30f84626a..8b84d1b22d4 100644
--- a/vendor/github.com/gogo/protobuf/proto/encode.go
+++ b/vendor/github.com/gogo/protobuf/proto/encode.go
@@ -174,11 +174,11 @@ func sizeFixed32(x uint64) int {
 // This is the format used for the sint64 protocol buffer type.
 func (p *Buffer) EncodeZigzag64(x uint64) error {
 	// use signed number to get arithmetic right shift.
-	return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+	return p.EncodeVarint((x << 1) ^ uint64((int64(x) >> 63)))
 }
 
 func sizeZigzag64(x uint64) int {
-	return sizeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+	return sizeVarint((x << 1) ^ uint64((int64(x) >> 63)))
 }
 
 // EncodeZigzag32 writes a zigzag-encoded 32-bit integer
diff --git a/vendor/github.com/gogo/protobuf/proto/lib.go b/vendor/github.com/gogo/protobuf/proto/lib.go
index 7580bb45c61..c98d73da49e 100644
--- a/vendor/github.com/gogo/protobuf/proto/lib.go
+++ b/vendor/github.com/gogo/protobuf/proto/lib.go
@@ -73,7 +73,6 @@ for a protocol buffer variable v:
 When the .proto file specifies `syntax="proto3"`, there are some differences:
 
   - Non-repeated fields of non-message type are values instead of pointers.
-  - Getters are only generated for message and oneof fields.
   - Enum types do not get an Enum method.
 
 The simplest way to describe this is to see an example.
diff --git a/vendor/github.com/gogo/protobuf/proto/properties.go b/vendor/github.com/gogo/protobuf/proto/properties.go
index 44b332052ef..2a69e8862d5 100644
--- a/vendor/github.com/gogo/protobuf/proto/properties.go
+++ b/vendor/github.com/gogo/protobuf/proto/properties.go
@@ -193,6 +193,7 @@ type Properties struct {
 	Default     string // default value
 	HasDefault  bool   // whether an explicit default was provided
 	CustomType  string
+	CastType    string
 	StdTime     bool
 	StdDuration bool
 
@@ -341,6 +342,8 @@ func (p *Properties) Parse(s string) {
 			p.OrigName = strings.Split(f, "=")[1]
 		case strings.HasPrefix(f, "customtype="):
 			p.CustomType = strings.Split(f, "=")[1]
+		case strings.HasPrefix(f, "casttype="):
+			p.CastType = strings.Split(f, "=")[1]
 		case f == "stdtime":
 			p.StdTime = true
 		case f == "stdduration":
diff --git a/vendor/github.com/gogo/protobuf/proto/text.go b/vendor/github.com/gogo/protobuf/proto/text.go
index d63732fcbda..f609d1d453b 100644
--- a/vendor/github.com/gogo/protobuf/proto/text.go
+++ b/vendor/github.com/gogo/protobuf/proto/text.go
@@ -522,6 +522,17 @@ func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Propert
 				}
 				return nil
 			}
+		} else if len(props.CastType) > 0 {
+			if _, ok := v.Interface().(interface {
+				String() string
+			}); ok {
+				switch v.Kind() {
+				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+					reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+					_, err := fmt.Fprintf(w, "%d", v.Interface())
+					return err
+				}
+			}
 		} else if props.StdTime {
 			t, ok := v.Interface().(time.Time)
 			if !ok {
@@ -531,9 +542,9 @@ func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Propert
 			if err != nil {
 				return err
 			}
-			props.StdTime = false
-			err = tm.writeAny(w, reflect.ValueOf(tproto), props)
-			props.StdTime = true
+			propsCopy := *props // Make a copy so that this is goroutine-safe
+			propsCopy.StdTime = false
+			err = tm.writeAny(w, reflect.ValueOf(tproto), &propsCopy)
 			return err
 		} else if props.StdDuration {
 			d, ok := v.Interface().(time.Duration)
@@ -541,9 +552,9 @@ func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Propert
 				return fmt.Errorf("stdtime is not time.Duration, but %T", v.Interface())
 			}
 			dproto := durationProto(d)
-			props.StdDuration = false
-			err := tm.writeAny(w, reflect.ValueOf(dproto), props)
-			props.StdDuration = true
+			propsCopy := *props // Make a copy so that this is goroutine-safe
+			propsCopy.StdDuration = false
+			err := tm.writeAny(w, reflect.ValueOf(dproto), &propsCopy)
 			return err
 		}
 	}
diff --git a/vendor/github.com/gogo/protobuf/proto/text_parser.go b/vendor/github.com/gogo/protobuf/proto/text_parser.go
index 9db12e96018..f1276729a35 100644
--- a/vendor/github.com/gogo/protobuf/proto/text_parser.go
+++ b/vendor/github.com/gogo/protobuf/proto/text_parser.go
@@ -983,7 +983,7 @@ func (p *textParser) readAny(v reflect.Value, props *Properties) error {
 		return p.readStruct(fv, terminator)
 	case reflect.Uint32:
 		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
-			fv.SetUint(uint64(x))
+			fv.SetUint(x)
 			return nil
 		}
 	case reflect.Uint64:
diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go
index e2703901b01..82623f0497b 100644
--- a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go
+++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: descriptor.proto
-// DO NOT EDIT!
 
 /*
 Package descriptor is a generated protocol buffer package.
@@ -12,6 +11,7 @@ It has these top-level messages:
 	FileDescriptorSet
 	FileDescriptorProto
 	DescriptorProto
+	ExtensionRangeOptions
 	FieldDescriptorProto
 	OneofDescriptorProto
 	EnumDescriptorProto
@@ -139,7 +139,7 @@ func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error {
 	return nil
 }
 func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptorDescriptor, []int{3, 0}
+	return fileDescriptorDescriptor, []int{4, 0}
 }
 
 type FieldDescriptorProto_Label int32
@@ -179,7 +179,7 @@ func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error {
 	return nil
 }
 func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptorDescriptor, []int{3, 1}
+	return fileDescriptorDescriptor, []int{4, 1}
 }
 
 // Generated classes can be optimized for speed or code size.
@@ -220,7 +220,7 @@ func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error {
 	return nil
 }
 func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptorDescriptor, []int{9, 0}
+	return fileDescriptorDescriptor, []int{10, 0}
 }
 
 type FieldOptions_CType int32
@@ -260,7 +260,7 @@ func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error {
 	return nil
 }
 func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptorDescriptor, []int{11, 0}
+	return fileDescriptorDescriptor, []int{12, 0}
 }
 
 type FieldOptions_JSType int32
@@ -302,7 +302,7 @@ func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error {
 	return nil
 }
 func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptorDescriptor, []int{11, 1}
+	return fileDescriptorDescriptor, []int{12, 1}
 }
 
 // Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
@@ -344,7 +344,7 @@ func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(data []byte) error {
 	return nil
 }
 func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptorDescriptor, []int{16, 0}
+	return fileDescriptorDescriptor, []int{17, 0}
 }
 
 // The protocol compiler can output a FileDescriptorSet containing the .proto
@@ -576,9 +576,10 @@ func (m *DescriptorProto) GetReservedName() []string {
 }
 
 type DescriptorProto_ExtensionRange struct {
-	Start            *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
-	End              *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
+	Start            *int32                 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
+	End              *int32                 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+	Options          *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+	XXX_unrecognized []byte                 `json:"-"`
 }
 
 func (m *DescriptorProto_ExtensionRange) Reset()         { *m = DescriptorProto_ExtensionRange{} }
@@ -602,6 +603,13 @@ func (m *DescriptorProto_ExtensionRange) GetEnd() int32 {
 	return 0
 }
 
+func (m *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
 // Range of reserved tag numbers. Reserved tag numbers may not be used by
 // fields or extension ranges in the same message. Reserved ranges may
 // not overlap.
@@ -632,6 +640,33 @@ func (m *DescriptorProto_ReservedRange) GetEnd() int32 {
 	return 0
 }
 
+type ExtensionRangeOptions struct {
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+}
+
+func (m *ExtensionRangeOptions) Reset()                    { *m = ExtensionRangeOptions{} }
+func (m *ExtensionRangeOptions) String() string            { return proto.CompactTextString(m) }
+func (*ExtensionRangeOptions) ProtoMessage()               {}
+func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{3} }
+
+var extRange_ExtensionRangeOptions = []proto.ExtensionRange{
+	{Start: 1000, End: 536870911},
+}
+
+func (*ExtensionRangeOptions) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_ExtensionRangeOptions
+}
+
+func (m *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if m != nil {
+		return m.UninterpretedOption
+	}
+	return nil
+}
+
 // Describes a field within a message.
 type FieldDescriptorProto struct {
 	Name   *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
@@ -670,7 +705,7 @@ type FieldDescriptorProto struct {
 func (m *FieldDescriptorProto) Reset()                    { *m = FieldDescriptorProto{} }
 func (m *FieldDescriptorProto) String() string            { return proto.CompactTextString(m) }
 func (*FieldDescriptorProto) ProtoMessage()               {}
-func (*FieldDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{3} }
+func (*FieldDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{4} }
 
 func (m *FieldDescriptorProto) GetName() string {
 	if m != nil && m.Name != nil {
@@ -752,7 +787,7 @@ type OneofDescriptorProto struct {
 func (m *OneofDescriptorProto) Reset()                    { *m = OneofDescriptorProto{} }
 func (m *OneofDescriptorProto) String() string            { return proto.CompactTextString(m) }
 func (*OneofDescriptorProto) ProtoMessage()               {}
-func (*OneofDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{4} }
+func (*OneofDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{5} }
 
 func (m *OneofDescriptorProto) GetName() string {
 	if m != nil && m.Name != nil {
@@ -779,7 +814,7 @@ type EnumDescriptorProto struct {
 func (m *EnumDescriptorProto) Reset()                    { *m = EnumDescriptorProto{} }
 func (m *EnumDescriptorProto) String() string            { return proto.CompactTextString(m) }
 func (*EnumDescriptorProto) ProtoMessage()               {}
-func (*EnumDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{5} }
+func (*EnumDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{6} }
 
 func (m *EnumDescriptorProto) GetName() string {
 	if m != nil && m.Name != nil {
@@ -814,7 +849,7 @@ func (m *EnumValueDescriptorProto) Reset()         { *m = EnumValueDescriptorPro
 func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) }
 func (*EnumValueDescriptorProto) ProtoMessage()    {}
 func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptorDescriptor, []int{6}
+	return fileDescriptorDescriptor, []int{7}
 }
 
 func (m *EnumValueDescriptorProto) GetName() string {
@@ -849,7 +884,7 @@ type ServiceDescriptorProto struct {
 func (m *ServiceDescriptorProto) Reset()                    { *m = ServiceDescriptorProto{} }
 func (m *ServiceDescriptorProto) String() string            { return proto.CompactTextString(m) }
 func (*ServiceDescriptorProto) ProtoMessage()               {}
-func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{7} }
+func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{8} }
 
 func (m *ServiceDescriptorProto) GetName() string {
 	if m != nil && m.Name != nil {
@@ -890,7 +925,7 @@ type MethodDescriptorProto struct {
 func (m *MethodDescriptorProto) Reset()                    { *m = MethodDescriptorProto{} }
 func (m *MethodDescriptorProto) String() string            { return proto.CompactTextString(m) }
 func (*MethodDescriptorProto) ProtoMessage()               {}
-func (*MethodDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{8} }
+func (*MethodDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{9} }
 
 const Default_MethodDescriptorProto_ClientStreaming bool = false
 const Default_MethodDescriptorProto_ServerStreaming bool = false
@@ -985,6 +1020,7 @@ type FileOptions struct {
 	CcGenericServices   *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
 	JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
 	PyGenericServices   *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
+	PhpGenericServices  *bool `protobuf:"varint,19,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"`
 	// Is this file deprecated?
 	// Depending on the target platform, this can emit Deprecated annotations
 	// for everything in the file, or it will be completely ignored; in the very
@@ -1003,6 +1039,13 @@ type FileOptions struct {
 	// defined. When this options is provided, they will use this value instead
 	// to prefix the types/symbols defined.
 	SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
+	// Sets the php class prefix which is prepended to all php generated classes
+	// from this .proto. Default is empty.
+	PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
+	// Use this option to change the namespace of php generated classes. Default
+	// is empty. When this option is empty, the package name will be used for
+	// determining the namespace.
+	PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
 	// The parser stores options it doesn't recognize here. See above.
 	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
 	proto.XXX_InternalExtensions `json:"-"`
@@ -1012,7 +1055,7 @@ type FileOptions struct {
 func (m *FileOptions) Reset()                    { *m = FileOptions{} }
 func (m *FileOptions) String() string            { return proto.CompactTextString(m) }
 func (*FileOptions) ProtoMessage()               {}
-func (*FileOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{9} }
+func (*FileOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{10} }
 
 var extRange_FileOptions = []proto.ExtensionRange{
 	{Start: 1000, End: 536870911},
@@ -1028,6 +1071,7 @@ const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPE
 const Default_FileOptions_CcGenericServices bool = false
 const Default_FileOptions_JavaGenericServices bool = false
 const Default_FileOptions_PyGenericServices bool = false
+const Default_FileOptions_PhpGenericServices bool = false
 const Default_FileOptions_Deprecated bool = false
 const Default_FileOptions_CcEnableArenas bool = false
 
@@ -1101,6 +1145,13 @@ func (m *FileOptions) GetPyGenericServices() bool {
 	return Default_FileOptions_PyGenericServices
 }
 
+func (m *FileOptions) GetPhpGenericServices() bool {
+	if m != nil && m.PhpGenericServices != nil {
+		return *m.PhpGenericServices
+	}
+	return Default_FileOptions_PhpGenericServices
+}
+
 func (m *FileOptions) GetDeprecated() bool {
 	if m != nil && m.Deprecated != nil {
 		return *m.Deprecated
@@ -1136,6 +1187,20 @@ func (m *FileOptions) GetSwiftPrefix() string {
 	return ""
 }
 
+func (m *FileOptions) GetPhpClassPrefix() string {
+	if m != nil && m.PhpClassPrefix != nil {
+		return *m.PhpClassPrefix
+	}
+	return ""
+}
+
+func (m *FileOptions) GetPhpNamespace() string {
+	if m != nil && m.PhpNamespace != nil {
+		return *m.PhpNamespace
+	}
+	return ""
+}
+
 func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
 	if m != nil {
 		return m.UninterpretedOption
@@ -1203,7 +1268,7 @@ type MessageOptions struct {
 func (m *MessageOptions) Reset()                    { *m = MessageOptions{} }
 func (m *MessageOptions) String() string            { return proto.CompactTextString(m) }
 func (*MessageOptions) ProtoMessage()               {}
-func (*MessageOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{10} }
+func (*MessageOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{11} }
 
 var extRange_MessageOptions = []proto.ExtensionRange{
 	{Start: 1000, End: 536870911},
@@ -1266,13 +1331,15 @@ type FieldOptions struct {
 	Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
 	// The jstype option determines the JavaScript type used for values of the
 	// field.  The option is permitted only for 64 bit integral and fixed types
-	// (int64, uint64, sint64, fixed64, sfixed64).  By default these types are
-	// represented as JavaScript strings.  This avoids loss of precision that can
-	// happen when a large value is converted to a floating point JavaScript
-	// numbers.  Specifying JS_NUMBER for the jstype causes the generated
-	// JavaScript code to use the JavaScript "number" type instead of strings.
-	// This option is an enum to permit additional types to be added,
-	// e.g. goog.math.Integer.
+	// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
+	// is represented as JavaScript string, which avoids loss of precision that
+	// can happen when a large value is converted to a floating point JavaScript.
+	// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
+	// use the JavaScript "number" type.  The behavior of the default option
+	// JS_NORMAL is implementation dependent.
+	//
+	// This option is an enum to permit additional types to be added, e.g.
+	// goog.math.Integer.
 	Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
 	// Should this field be parsed lazily?  Lazy applies only to message-type
 	// fields.  It means that when the outer message is initially parsed, the
@@ -1319,7 +1386,7 @@ type FieldOptions struct {
 func (m *FieldOptions) Reset()                    { *m = FieldOptions{} }
 func (m *FieldOptions) String() string            { return proto.CompactTextString(m) }
 func (*FieldOptions) ProtoMessage()               {}
-func (*FieldOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{11} }
+func (*FieldOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{12} }
 
 var extRange_FieldOptions = []proto.ExtensionRange{
 	{Start: 1000, End: 536870911},
@@ -1394,7 +1461,7 @@ type OneofOptions struct {
 func (m *OneofOptions) Reset()                    { *m = OneofOptions{} }
 func (m *OneofOptions) String() string            { return proto.CompactTextString(m) }
 func (*OneofOptions) ProtoMessage()               {}
-func (*OneofOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{12} }
+func (*OneofOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{13} }
 
 var extRange_OneofOptions = []proto.ExtensionRange{
 	{Start: 1000, End: 536870911},
@@ -1429,7 +1496,7 @@ type EnumOptions struct {
 func (m *EnumOptions) Reset()                    { *m = EnumOptions{} }
 func (m *EnumOptions) String() string            { return proto.CompactTextString(m) }
 func (*EnumOptions) ProtoMessage()               {}
-func (*EnumOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{13} }
+func (*EnumOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{14} }
 
 var extRange_EnumOptions = []proto.ExtensionRange{
 	{Start: 1000, End: 536870911},
@@ -1477,7 +1544,7 @@ type EnumValueOptions struct {
 func (m *EnumValueOptions) Reset()                    { *m = EnumValueOptions{} }
 func (m *EnumValueOptions) String() string            { return proto.CompactTextString(m) }
 func (*EnumValueOptions) ProtoMessage()               {}
-func (*EnumValueOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{14} }
+func (*EnumValueOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{15} }
 
 var extRange_EnumValueOptions = []proto.ExtensionRange{
 	{Start: 1000, End: 536870911},
@@ -1518,7 +1585,7 @@ type ServiceOptions struct {
 func (m *ServiceOptions) Reset()                    { *m = ServiceOptions{} }
 func (m *ServiceOptions) String() string            { return proto.CompactTextString(m) }
 func (*ServiceOptions) ProtoMessage()               {}
-func (*ServiceOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{15} }
+func (*ServiceOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{16} }
 
 var extRange_ServiceOptions = []proto.ExtensionRange{
 	{Start: 1000, End: 536870911},
@@ -1560,7 +1627,7 @@ type MethodOptions struct {
 func (m *MethodOptions) Reset()                    { *m = MethodOptions{} }
 func (m *MethodOptions) String() string            { return proto.CompactTextString(m) }
 func (*MethodOptions) ProtoMessage()               {}
-func (*MethodOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{16} }
+func (*MethodOptions) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{17} }
 
 var extRange_MethodOptions = []proto.ExtensionRange{
 	{Start: 1000, End: 536870911},
@@ -1616,7 +1683,7 @@ type UninterpretedOption struct {
 func (m *UninterpretedOption) Reset()                    { *m = UninterpretedOption{} }
 func (m *UninterpretedOption) String() string            { return proto.CompactTextString(m) }
 func (*UninterpretedOption) ProtoMessage()               {}
-func (*UninterpretedOption) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{17} }
+func (*UninterpretedOption) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{18} }
 
 func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
 	if m != nil {
@@ -1682,7 +1749,7 @@ func (m *UninterpretedOption_NamePart) Reset()         { *m = UninterpretedOptio
 func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) }
 func (*UninterpretedOption_NamePart) ProtoMessage()    {}
 func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
-	return fileDescriptorDescriptor, []int{17, 0}
+	return fileDescriptorDescriptor, []int{18, 0}
 }
 
 func (m *UninterpretedOption_NamePart) GetNamePart() string {
@@ -1752,7 +1819,7 @@ type SourceCodeInfo struct {
 func (m *SourceCodeInfo) Reset()                    { *m = SourceCodeInfo{} }
 func (m *SourceCodeInfo) String() string            { return proto.CompactTextString(m) }
 func (*SourceCodeInfo) ProtoMessage()               {}
-func (*SourceCodeInfo) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{18} }
+func (*SourceCodeInfo) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{19} }
 
 func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
 	if m != nil {
@@ -1849,7 +1916,7 @@ func (m *SourceCodeInfo_Location) Reset()         { *m = SourceCodeInfo_Location
 func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) }
 func (*SourceCodeInfo_Location) ProtoMessage()    {}
 func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
-	return fileDescriptorDescriptor, []int{18, 0}
+	return fileDescriptorDescriptor, []int{19, 0}
 }
 
 func (m *SourceCodeInfo_Location) GetPath() []int32 {
@@ -1900,7 +1967,7 @@ type GeneratedCodeInfo struct {
 func (m *GeneratedCodeInfo) Reset()                    { *m = GeneratedCodeInfo{} }
 func (m *GeneratedCodeInfo) String() string            { return proto.CompactTextString(m) }
 func (*GeneratedCodeInfo) ProtoMessage()               {}
-func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{19} }
+func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{20} }
 
 func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
 	if m != nil {
@@ -1929,7 +1996,7 @@ func (m *GeneratedCodeInfo_Annotation) Reset()         { *m = GeneratedCodeInfo_
 func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) }
 func (*GeneratedCodeInfo_Annotation) ProtoMessage()    {}
 func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
-	return fileDescriptorDescriptor, []int{19, 0}
+	return fileDescriptorDescriptor, []int{20, 0}
 }
 
 func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 {
@@ -1966,6 +2033,7 @@ func init() {
 	proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto")
 	proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange")
 	proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange")
+	proto.RegisterType((*ExtensionRangeOptions)(nil), "google.protobuf.ExtensionRangeOptions")
 	proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto")
 	proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto")
 	proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto")
@@ -1997,154 +2065,159 @@ func init() {
 func init() { proto.RegisterFile("descriptor.proto", fileDescriptorDescriptor) }
 
 var fileDescriptorDescriptor = []byte{
-	// 2379 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xcd, 0x73, 0xdb, 0xc6,
-	0x15, 0x37, 0xc1, 0x0f, 0x91, 0x8f, 0x14, 0xb5, 0x5a, 0x29, 0x36, 0x2c, 0xc7, 0xb1, 0xcc, 0xd8,
-	0xb5, 0x6c, 0xb7, 0x74, 0x46, 0xfe, 0x88, 0xa3, 0x74, 0xd2, 0xa1, 0x48, 0x58, 0xa1, 0x4b, 0x91,
-	0x2c, 0x48, 0x35, 0x76, 0x2e, 0x98, 0x15, 0xb0, 0xa4, 0x60, 0x83, 0x00, 0x02, 0x80, 0xb6, 0x95,
-	0x93, 0x67, 0x7a, 0xea, 0x7f, 0xd0, 0xe9, 0x74, 0x7a, 0xc8, 0x25, 0x33, 0xed, 0xbd, 0x87, 0xde,
-	0x7b, 0xed, 0x4c, 0xef, 0x3d, 0xf4, 0xd0, 0x99, 0xf6, 0x3f, 0xe8, 0xb5, 0xb3, 0xbb, 0x00, 0x08,
-	0x7e, 0xd9, 0x4a, 0x66, 0x9c, 0x9c, 0xa4, 0xfd, 0xbd, 0xdf, 0x7b, 0x78, 0xfb, 0xf6, 0x87, 0xdd,
-	0x87, 0x25, 0x20, 0x83, 0xfa, 0xba, 0x67, 0xba, 0x81, 0xe3, 0x55, 0x5d, 0xcf, 0x09, 0x1c, 0xbc,
-	0x36, 0x74, 0x9c, 0xa1, 0x45, 0xc5, 0xe8, 0x78, 0x3c, 0xa8, 0x1c, 0xc2, 0xfa, 0x23, 0xd3, 0xa2,
-	0x8d, 0x98, 0xd8, 0xa3, 0x01, 0x7e, 0x08, 0x99, 0x81, 0x69, 0x51, 0x39, 0xb5, 0x9d, 0xde, 0x29,
-	0xee, 0x5e, 0xab, 0xce, 0x38, 0x55, 0xa7, 0x3d, 0xba, 0x0c, 0x56, 0xb9, 0x47, 0xe5, 0xdf, 0x19,
-	0xd8, 0x58, 0x60, 0xc5, 0x18, 0x32, 0x36, 0x19, 0xb1, 0x88, 0xa9, 0x9d, 0x82, 0xca, 0xff, 0xc7,
-	0x32, 0xac, 0xb8, 0x44, 0x7f, 0x4e, 0x86, 0x54, 0x96, 0x38, 0x1c, 0x0d, 0xf1, 0x07, 0x00, 0x06,
-	0x75, 0xa9, 0x6d, 0x50, 0x5b, 0x3f, 0x95, 0xd3, 0xdb, 0xe9, 0x9d, 0x82, 0x9a, 0x40, 0xf0, 0x6d,
-	0x58, 0x77, 0xc7, 0xc7, 0x96, 0xa9, 0x6b, 0x09, 0x1a, 0x6c, 0xa7, 0x77, 0xb2, 0x2a, 0x12, 0x86,
-	0xc6, 0x84, 0x7c, 0x03, 0xd6, 0x5e, 0x52, 0xf2, 0x3c, 0x49, 0x2d, 0x72, 0x6a, 0x99, 0xc1, 0x09,
-	0x62, 0x1d, 0x4a, 0x23, 0xea, 0xfb, 0x64, 0x48, 0xb5, 0xe0, 0xd4, 0xa5, 0x72, 0x86, 0xcf, 0x7e,
-	0x7b, 0x6e, 0xf6, 0xb3, 0x33, 0x2f, 0x86, 0x5e, 0xfd, 0x53, 0x97, 0xe2, 0x1a, 0x14, 0xa8, 0x3d,
-	0x1e, 0x89, 0x08, 0xd9, 0x25, 0xf5, 0x53, 0xec, 0xf1, 0x68, 0x36, 0x4a, 0x9e, 0xb9, 0x85, 0x21,
-	0x56, 0x7c, 0xea, 0xbd, 0x30, 0x75, 0x2a, 0xe7, 0x78, 0x80, 0x1b, 0x73, 0x01, 0x7a, 0xc2, 0x3e,
-	0x1b, 0x23, 0xf2, 0xc3, 0x75, 0x28, 0xd0, 0x57, 0x01, 0xb5, 0x7d, 0xd3, 0xb1, 0xe5, 0x15, 0x1e,
-	0xe4, 0xfa, 0x82, 0x55, 0xa4, 0x96, 0x31, 0x1b, 0x62, 0xe2, 0x87, 0x1f, 0xc0, 0x8a, 0xe3, 0x06,
-	0xa6, 0x63, 0xfb, 0x72, 0x7e, 0x3b, 0xb5, 0x53, 0xdc, 0x7d, 0x7f, 0xa1, 0x10, 0x3a, 0x82, 0xa3,
-	0x46, 0x64, 0xdc, 0x04, 0xe4, 0x3b, 0x63, 0x4f, 0xa7, 0x9a, 0xee, 0x18, 0x54, 0x33, 0xed, 0x81,
-	0x23, 0x17, 0x78, 0x80, 0x2b, 0xf3, 0x13, 0xe1, 0xc4, 0xba, 0x63, 0xd0, 0xa6, 0x3d, 0x70, 0xd4,
-	0xb2, 0x3f, 0x35, 0xc6, 0xe7, 0x21, 0xe7, 0x9f, 0xda, 0x01, 0x79, 0x25, 0x97, 0xb8, 0x42, 0xc2,
-	0x51, 0xe5, 0x7f, 0x59, 0x58, 0x3b, 0x8b, 0xc4, 0x3e, 0x85, 0xec, 0x80, 0xcd, 0x52, 0x96, 0xbe,
-	0x4b, 0x0d, 0x84, 0xcf, 0x74, 0x11, 0x73, 0xdf, 0xb3, 0x88, 0x35, 0x28, 0xda, 0xd4, 0x0f, 0xa8,
-	0x21, 0x14, 0x91, 0x3e, 0xa3, 0xa6, 0x40, 0x38, 0xcd, 0x4b, 0x2a, 0xf3, 0xbd, 0x24, 0xf5, 0x04,
-	0xd6, 0xe2, 0x94, 0x34, 0x8f, 0xd8, 0xc3, 0x48, 0x9b, 0x77, 0xde, 0x96, 0x49, 0x55, 0x89, 0xfc,
-	0x54, 0xe6, 0xa6, 0x96, 0xe9, 0xd4, 0x18, 0x37, 0x00, 0x1c, 0x9b, 0x3a, 0x03, 0xcd, 0xa0, 0xba,
-	0x25, 0xe7, 0x97, 0x54, 0xa9, 0xc3, 0x28, 0x73, 0x55, 0x72, 0x04, 0xaa, 0x5b, 0xf8, 0x93, 0x89,
-	0xd4, 0x56, 0x96, 0x28, 0xe5, 0x50, 0xbc, 0x64, 0x73, 0x6a, 0x3b, 0x82, 0xb2, 0x47, 0x99, 0xee,
-	0xa9, 0x11, 0xce, 0xac, 0xc0, 0x93, 0xa8, 0xbe, 0x75, 0x66, 0x6a, 0xe8, 0x26, 0x26, 0xb6, 0xea,
-	0x25, 0x87, 0xf8, 0x43, 0x88, 0x01, 0x8d, 0xcb, 0x0a, 0xf8, 0x2e, 0x54, 0x8a, 0xc0, 0x36, 0x19,
-	0xd1, 0xad, 0x87, 0x50, 0x9e, 0x2e, 0x0f, 0xde, 0x84, 0xac, 0x1f, 0x10, 0x2f, 0xe0, 0x2a, 0xcc,
-	0xaa, 0x62, 0x80, 0x11, 0xa4, 0xa9, 0x6d, 0xf0, 0x5d, 0x2e, 0xab, 0xb2, 0x7f, 0xb7, 0x3e, 0x86,
-	0xd5, 0xa9, 0xc7, 0x9f, 0xd5, 0xb1, 0xf2, 0xbb, 0x1c, 0x6c, 0x2e, 0xd2, 0xdc, 0x42, 0xf9, 0x9f,
-	0x87, 0x9c, 0x3d, 0x1e, 0x1d, 0x53, 0x4f, 0x4e, 0xf3, 0x08, 0xe1, 0x08, 0xd7, 0x20, 0x6b, 0x91,
-	0x63, 0x6a, 0xc9, 0x99, 0xed, 0xd4, 0x4e, 0x79, 0xf7, 0xf6, 0x99, 0x54, 0x5d, 0x6d, 0x31, 0x17,
-	0x55, 0x78, 0xe2, 0xcf, 0x20, 0x13, 0x6e, 0x71, 0x2c, 0xc2, 0xad, 0xb3, 0x45, 0x60, 0x5a, 0x54,
-	0xb9, 0x1f, 0xbe, 0x04, 0x05, 0xf6, 0x57, 0xd4, 0x36, 0xc7, 0x73, 0xce, 0x33, 0x80, 0xd5, 0x15,
-	0x6f, 0x41, 0x9e, 0xcb, 0xcc, 0xa0, 0xd1, 0xd1, 0x10, 0x8f, 0xd9, 0xc2, 0x18, 0x74, 0x40, 0xc6,
-	0x56, 0xa0, 0xbd, 0x20, 0xd6, 0x98, 0x72, 0xc1, 0x14, 0xd4, 0x52, 0x08, 0xfe, 0x9a, 0x61, 0xf8,
-	0x0a, 0x14, 0x85, 0x2a, 0x4d, 0xdb, 0xa0, 0xaf, 0xf8, 0xee, 0x93, 0x55, 0x85, 0x50, 0x9b, 0x0c,
-	0x61, 0x8f, 0x7f, 0xe6, 0x3b, 0x76, 0xb4, 0xb4, 0xfc, 0x11, 0x0c, 0xe0, 0x8f, 0xff, 0x78, 0x76,
-	0xe3, 0xbb, 0xbc, 0x78, 0x7a, 0xb3, 0x5a, 0xac, 0xfc, 0x45, 0x82, 0x0c, 0x7f, 0xdf, 0xd6, 0xa0,
-	0xd8, 0x7f, 0xda, 0x55, 0xb4, 0x46, 0xe7, 0x68, 0xbf, 0xa5, 0xa0, 0x14, 0x2e, 0x03, 0x70, 0xe0,
-	0x51, 0xab, 0x53, 0xeb, 0x23, 0x29, 0x1e, 0x37, 0xdb, 0xfd, 0x07, 0xf7, 0x50, 0x3a, 0x76, 0x38,
-	0x12, 0x40, 0x26, 0x49, 0xb8, 0xbb, 0x8b, 0xb2, 0x18, 0x41, 0x49, 0x04, 0x68, 0x3e, 0x51, 0x1a,
-	0x0f, 0xee, 0xa1, 0xdc, 0x34, 0x72, 0x77, 0x17, 0xad, 0xe0, 0x55, 0x28, 0x70, 0x64, 0xbf, 0xd3,
-	0x69, 0xa1, 0x7c, 0x1c, 0xb3, 0xd7, 0x57, 0x9b, 0xed, 0x03, 0x54, 0x88, 0x63, 0x1e, 0xa8, 0x9d,
-	0xa3, 0x2e, 0x82, 0x38, 0xc2, 0xa1, 0xd2, 0xeb, 0xd5, 0x0e, 0x14, 0x54, 0x8c, 0x19, 0xfb, 0x4f,
-	0xfb, 0x4a, 0x0f, 0x95, 0xa6, 0xd2, 0xba, 0xbb, 0x8b, 0x56, 0xe3, 0x47, 0x28, 0xed, 0xa3, 0x43,
-	0x54, 0xc6, 0xeb, 0xb0, 0x2a, 0x1e, 0x11, 0x25, 0xb1, 0x36, 0x03, 0x3d, 0xb8, 0x87, 0xd0, 0x24,
-	0x11, 0x11, 0x65, 0x7d, 0x0a, 0x78, 0x70, 0x0f, 0xe1, 0x4a, 0x1d, 0xb2, 0x5c, 0x5d, 0x18, 0x43,
-	0xb9, 0x55, 0xdb, 0x57, 0x5a, 0x5a, 0xa7, 0xdb, 0x6f, 0x76, 0xda, 0xb5, 0x16, 0x4a, 0x4d, 0x30,
-	0x55, 0xf9, 0xd5, 0x51, 0x53, 0x55, 0x1a, 0x48, 0x4a, 0x62, 0x5d, 0xa5, 0xd6, 0x57, 0x1a, 0x28,
-	0x5d, 0xd1, 0x61, 0x73, 0xd1, 0x3e, 0xb3, 0xf0, 0xcd, 0x48, 0x2c, 0xb1, 0xb4, 0x64, 0x89, 0x79,
-	0xac, 0xb9, 0x25, 0xfe, 0x26, 0x05, 0x1b, 0x0b, 0xf6, 0xda, 0x85, 0x0f, 0xf9, 0x05, 0x64, 0x85,
-	0x44, 0xc5, 0xe9, 0x73, 0x73, 0xe1, 0xa6, 0xcd, 0x05, 0x3b, 0x77, 0x02, 0x71, 0xbf, 0xe4, 0x09,
-	0x9c, 0x5e, 0x72, 0x02, 0xb3, 0x10, 0x73, 0x49, 0xfe, 0x26, 0x05, 0xf2, 0xb2, 0xd8, 0x6f, 0xd9,
-	0x28, 0xa4, 0xa9, 0x8d, 0xe2, 0xd3, 0xd9, 0x04, 0xae, 0x2e, 0x9f, 0xc3, 0x5c, 0x16, 0xdf, 0xa6,
-	0xe0, 0xfc, 0xe2, 0x46, 0x65, 0x61, 0x0e, 0x9f, 0x41, 0x6e, 0x44, 0x83, 0x13, 0x27, 0x3a, 0xac,
-	0x7f, 0xb2, 0xe0, 0x08, 0x60, 0xe6, 0xd9, 0x5a, 0x85, 0x5e, 0xc9, 0x33, 0x24, 0xbd, 0xac, 0xdb,
-	0x10, 0xd9, 0xcc, 0x65, 0xfa, 0x5b, 0x09, 0xde, 0x5b, 0x18, 0x7c, 0x61, 0xa2, 0x97, 0x01, 0x4c,
-	0xdb, 0x1d, 0x07, 0xe2, 0x40, 0x16, 0xfb, 0x53, 0x81, 0x23, 0xfc, 0xdd, 0x67, 0x7b, 0xcf, 0x38,
-	0x88, 0xed, 0x69, 0x6e, 0x07, 0x01, 0x71, 0xc2, 0xc3, 0x49, 0xa2, 0x19, 0x9e, 0xe8, 0x07, 0x4b,
-	0x66, 0x3a, 0x77, 0xd6, 0x7d, 0x04, 0x48, 0xb7, 0x4c, 0x6a, 0x07, 0x9a, 0x1f, 0x78, 0x94, 0x8c,
-	0x4c, 0x7b, 0xc8, 0x37, 0xe0, 0xfc, 0x5e, 0x76, 0x40, 0x2c, 0x9f, 0xaa, 0x6b, 0xc2, 0xdc, 0x8b,
-	0xac, 0xcc, 0x83, 0x9f, 0x32, 0x5e, 0xc2, 0x23, 0x37, 0xe5, 0x21, 0xcc, 0xb1, 0x47, 0xe5, 0xcf,
-	0x2b, 0x50, 0x4c, 0xb4, 0x75, 0xf8, 0x2a, 0x94, 0x9e, 0x91, 0x17, 0x44, 0x8b, 0x5a, 0x75, 0x51,
-	0x89, 0x22, 0xc3, 0xba, 0x61, 0xbb, 0xfe, 0x11, 0x6c, 0x72, 0x8a, 0x33, 0x0e, 0xa8, 0xa7, 0xe9,
-	0x16, 0xf1, 0x7d, 0x5e, 0xb4, 0x3c, 0xa7, 0x62, 0x66, 0xeb, 0x30, 0x53, 0x3d, 0xb2, 0xe0, 0xfb,
-	0xb0, 0xc1, 0x3d, 0x46, 0x63, 0x2b, 0x30, 0x5d, 0x8b, 0x6a, 0xec, 0xe3, 0xc1, 0xe7, 0x1b, 0x71,
-	0x9c, 0xd9, 0x3a, 0x63, 0x1c, 0x86, 0x04, 0x96, 0x91, 0x8f, 0x1b, 0x70, 0x99, 0xbb, 0x0d, 0xa9,
-	0x4d, 0x3d, 0x12, 0x50, 0x8d, 0x7e, 0x35, 0x26, 0x96, 0xaf, 0x11, 0xdb, 0xd0, 0x4e, 0x88, 0x7f,
-	0x22, 0x6f, 0xb2, 0x00, 0xfb, 0x92, 0x9c, 0x52, 0x2f, 0x32, 0xe2, 0x41, 0xc8, 0x53, 0x38, 0xad,
-	0x66, 0x1b, 0x9f, 0x13, 0xff, 0x04, 0xef, 0xc1, 0x79, 0x1e, 0xc5, 0x0f, 0x3c, 0xd3, 0x1e, 0x6a,
-	0xfa, 0x09, 0xd5, 0x9f, 0x6b, 0xe3, 0x60, 0xf0, 0x50, 0xbe, 0x94, 0x7c, 0x3e, 0xcf, 0xb0, 0xc7,
-	0x39, 0x75, 0x46, 0x39, 0x0a, 0x06, 0x0f, 0x71, 0x0f, 0x4a, 0x6c, 0x31, 0x46, 0xe6, 0xd7, 0x54,
-	0x1b, 0x38, 0x1e, 0x3f, 0x59, 0xca, 0x0b, 0xde, 0xec, 0x44, 0x05, 0xab, 0x9d, 0xd0, 0xe1, 0xd0,
-	0x31, 0xe8, 0x5e, 0xb6, 0xd7, 0x55, 0x94, 0x86, 0x5a, 0x8c, 0xa2, 0x3c, 0x72, 0x3c, 0x26, 0xa8,
-	0xa1, 0x13, 0x17, 0xb8, 0x28, 0x04, 0x35, 0x74, 0xa2, 0xf2, 0xde, 0x87, 0x0d, 0x5d, 0x17, 0x73,
-	0x36, 0x75, 0x2d, 0x6c, 0xf1, 0x7d, 0x19, 0x4d, 0x15, 0x4b, 0xd7, 0x0f, 0x04, 0x21, 0xd4, 0xb8,
-	0x8f, 0x3f, 0x81, 0xf7, 0x26, 0xc5, 0x4a, 0x3a, 0xae, 0xcf, 0xcd, 0x72, 0xd6, 0xf5, 0x3e, 0x6c,
-	0xb8, 0xa7, 0xf3, 0x8e, 0x78, 0xea, 0x89, 0xee, 0xe9, 0xac, 0xdb, 0x75, 0xfe, 0xd9, 0xe6, 0x51,
-	0x9d, 0x04, 0xd4, 0x90, 0x2f, 0x24, 0xd9, 0x09, 0x03, 0xbe, 0x03, 0x48, 0xd7, 0x35, 0x6a, 0x93,
-	0x63, 0x8b, 0x6a, 0xc4, 0xa3, 0x36, 0xf1, 0xe5, 0x2b, 0x49, 0x72, 0x59, 0xd7, 0x15, 0x6e, 0xad,
-	0x71, 0x23, 0xbe, 0x05, 0xeb, 0xce, 0xf1, 0x33, 0x5d, 0x28, 0x4b, 0x73, 0x3d, 0x3a, 0x30, 0x5f,
-	0xc9, 0xd7, 0x78, 0x99, 0xd6, 0x98, 0x81, 0xeb, 0xaa, 0xcb, 0x61, 0x7c, 0x13, 0x90, 0xee, 0x9f,
-	0x10, 0xcf, 0xe5, 0x47, 0xbb, 0xef, 0x12, 0x9d, 0xca, 0xd7, 0x05, 0x55, 0xe0, 0xed, 0x08, 0x66,
-	0xca, 0xf6, 0x5f, 0x9a, 0x83, 0x20, 0x8a, 0x78, 0x43, 0x28, 0x9b, 0x63, 0x61, 0xb4, 0x27, 0xb0,
-	0x39, 0xb6, 0x4d, 0x3b, 0xa0, 0x9e, 0xeb, 0x51, 0xd6, 0xc4, 0x8b, 0x37, 0x51, 0xfe, 0xcf, 0xca,
-	0x92, 0x36, 0xfc, 0x28, 0xc9, 0x16, 0x02, 0x50, 0x37, 0xc6, 0xf3, 0x60, 0x65, 0x0f, 0x4a, 0x49,
-	0x5d, 0xe0, 0x02, 0x08, 0x65, 0xa0, 0x14, 0x3b, 0x63, 0xeb, 0x9d, 0x06, 0x3b, 0x1d, 0xbf, 0x54,
-	0x90, 0xc4, 0x4e, 0xe9, 0x56, 0xb3, 0xaf, 0x68, 0xea, 0x51, 0xbb, 0xdf, 0x3c, 0x54, 0x50, 0xfa,
-	0x56, 0x21, 0xff, 0xdf, 0x15, 0xf4, 0xfa, 0xf5, 0xeb, 0xd7, 0x52, 0xe5, 0x6f, 0x12, 0x94, 0xa7,
-	0x3b, 0x63, 0xfc, 0x73, 0xb8, 0x10, 0x7d, 0xc6, 0xfa, 0x34, 0xd0, 0x5e, 0x9a, 0x1e, 0x97, 0xea,
-	0x88, 0x88, 0xde, 0x32, 0xae, 0xf2, 0x66, 0xc8, 0xea, 0xd1, 0xe0, 0x0b, 0xd3, 0x63, 0x42, 0x1c,
-	0x91, 0x00, 0xb7, 0xe0, 0x8a, 0xed, 0x68, 0x7e, 0x40, 0x6c, 0x83, 0x78, 0x86, 0x36, 0xb9, 0x40,
-	0xd0, 0x88, 0xae, 0x53, 0xdf, 0x77, 0xc4, 0x11, 0x11, 0x47, 0x79, 0xdf, 0x76, 0x7a, 0x21, 0x79,
-	0xb2, 0x77, 0xd6, 0x42, 0xea, 0x8c, 0x22, 0xd2, 0xcb, 0x14, 0x71, 0x09, 0x0a, 0x23, 0xe2, 0x6a,
-	0xd4, 0x0e, 0xbc, 0x53, 0xde, 0xcf, 0xe5, 0xd5, 0xfc, 0x88, 0xb8, 0x0a, 0x1b, 0xbf, 0xbb, 0x35,
-	0x48, 0xd6, 0xf1, 0x9f, 0x69, 0x28, 0x25, 0x7b, 0x3a, 0xd6, 0x22, 0xeb, 0x7c, 0xff, 0x4e, 0xf1,
-	0x37, 0xfc, 0xc3, 0x37, 0x76, 0x80, 0xd5, 0x3a, 0xdb, 0xd8, 0xf7, 0x72, 0xa2, 0xd3, 0x52, 0x85,
-	0x27, 0x3b, 0x54, 0xd9, 0x3b, 0x4d, 0x45, 0xff, 0x9e, 0x57, 0xc3, 0x11, 0x3e, 0x80, 0xdc, 0x33,
-	0x9f, 0xc7, 0xce, 0xf1, 0xd8, 0xd7, 0xde, 0x1c, 0xfb, 0x71, 0x8f, 0x07, 0x2f, 0x3c, 0xee, 0x69,
-	0xed, 0x8e, 0x7a, 0x58, 0x6b, 0xa9, 0xa1, 0x3b, 0xbe, 0x08, 0x19, 0x8b, 0x7c, 0x7d, 0x3a, 0x7d,
-	0x04, 0x70, 0xe8, 0xac, 0x85, 0xbf, 0x08, 0x99, 0x97, 0x94, 0x3c, 0x9f, 0xde, 0x78, 0x39, 0xf4,
-	0x0e, 0xa5, 0x7f, 0x07, 0xb2, 0xbc, 0x5e, 0x18, 0x20, 0xac, 0x18, 0x3a, 0x87, 0xf3, 0x90, 0xa9,
-	0x77, 0x54, 0x26, 0x7f, 0x04, 0x25, 0x81, 0x6a, 0xdd, 0xa6, 0x52, 0x57, 0x90, 0x54, 0xb9, 0x0f,
-	0x39, 0x51, 0x04, 0xf6, 0x6a, 0xc4, 0x65, 0x40, 0xe7, 0xc2, 0x61, 0x18, 0x23, 0x15, 0x59, 0x8f,
-	0x0e, 0xf7, 0x15, 0x15, 0x49, 0xc9, 0xe5, 0xf5, 0xa1, 0x94, 0x6c, 0xe7, 0x7e, 0x18, 0x4d, 0xfd,
-	0x35, 0x05, 0xc5, 0x44, 0x7b, 0xc6, 0x1a, 0x03, 0x62, 0x59, 0xce, 0x4b, 0x8d, 0x58, 0x26, 0xf1,
-	0x43, 0x51, 0x00, 0x87, 0x6a, 0x0c, 0x39, 0xeb, 0xa2, 0xfd, 0x20, 0xc9, 0xff, 0x31, 0x05, 0x68,
-	0xb6, 0xb5, 0x9b, 0x49, 0x30, 0xf5, 0xa3, 0x26, 0xf8, 0x87, 0x14, 0x94, 0xa7, 0xfb, 0xb9, 0x99,
-	0xf4, 0xae, 0xfe, 0xa8, 0xe9, 0xfd, 0x4b, 0x82, 0xd5, 0xa9, 0x2e, 0xee, 0xac, 0xd9, 0x7d, 0x05,
-	0xeb, 0xa6, 0x41, 0x47, 0xae, 0x13, 0x50, 0x5b, 0x3f, 0xd5, 0x2c, 0xfa, 0x82, 0x5a, 0x72, 0x85,
-	0x6f, 0x14, 0x77, 0xde, 0xdc, 0x27, 0x56, 0x9b, 0x13, 0xbf, 0x16, 0x73, 0xdb, 0xdb, 0x68, 0x36,
-	0x94, 0xc3, 0x6e, 0xa7, 0xaf, 0xb4, 0xeb, 0x4f, 0xb5, 0xa3, 0xf6, 0x2f, 0xdb, 0x9d, 0x2f, 0xda,
-	0x2a, 0x32, 0x67, 0x68, 0xef, 0xf0, 0x55, 0xef, 0x02, 0x9a, 0x4d, 0x0a, 0x5f, 0x80, 0x45, 0x69,
-	0xa1, 0x73, 0x78, 0x03, 0xd6, 0xda, 0x1d, 0xad, 0xd7, 0x6c, 0x28, 0x9a, 0xf2, 0xe8, 0x91, 0x52,
-	0xef, 0xf7, 0xc4, 0x87, 0x73, 0xcc, 0xee, 0x4f, 0xbf, 0xd4, 0xbf, 0x4f, 0xc3, 0xc6, 0x82, 0x4c,
-	0x70, 0x2d, 0xec, 0xd9, 0xc5, 0x67, 0xc4, 0xcf, 0xce, 0x92, 0x7d, 0x95, 0x75, 0x05, 0x5d, 0xe2,
-	0x05, 0x61, 0x8b, 0x7f, 0x13, 0x58, 0x95, 0xec, 0xc0, 0x1c, 0x98, 0xd4, 0x0b, 0xef, 0x19, 0x44,
-	0x23, 0xbf, 0x36, 0xc1, 0xc5, 0x55, 0xc3, 0x4f, 0x01, 0xbb, 0x8e, 0x6f, 0x06, 0xe6, 0x0b, 0xaa,
-	0x99, 0x76, 0x74, 0x29, 0xc1, 0x1a, 0xfb, 0x8c, 0x8a, 0x22, 0x4b, 0xd3, 0x0e, 0x62, 0xb6, 0x4d,
-	0x87, 0x64, 0x86, 0xcd, 0x36, 0xf0, 0xb4, 0x8a, 0x22, 0x4b, 0xcc, 0xbe, 0x0a, 0x25, 0xc3, 0x19,
-	0xb3, 0x36, 0x49, 0xf0, 0xd8, 0x79, 0x91, 0x52, 0x8b, 0x02, 0x8b, 0x29, 0x61, 0x1f, 0x3b, 0xb9,
-	0x0d, 0x29, 0xa9, 0x45, 0x81, 0x09, 0xca, 0x0d, 0x58, 0x23, 0xc3, 0xa1, 0xc7, 0x82, 0x47, 0x81,
-	0x44, 0x67, 0x5e, 0x8e, 0x61, 0x4e, 0xdc, 0x7a, 0x0c, 0xf9, 0xa8, 0x0e, 0xec, 0x48, 0x66, 0x95,
-	0xd0, 0x5c, 0x71, 0x27, 0x25, 0xed, 0x14, 0xd4, 0xbc, 0x1d, 0x19, 0xaf, 0x42, 0xc9, 0xf4, 0xb5,
-	0xc9, 0xe5, 0xa8, 0xb4, 0x2d, 0xed, 0xe4, 0xd5, 0xa2, 0xe9, 0xc7, 0xb7, 0x61, 0x95, 0x6f, 0x25,
-	0x28, 0x4f, 0x5f, 0xee, 0xe2, 0x06, 0xe4, 0x2d, 0x47, 0x27, 0x5c, 0x5a, 0xe2, 0x97, 0x85, 0x9d,
-	0xb7, 0xdc, 0x07, 0x57, 0x5b, 0x21, 0x5f, 0x8d, 0x3d, 0xb7, 0xfe, 0x9e, 0x82, 0x7c, 0x04, 0xe3,
-	0xf3, 0x90, 0x71, 0x49, 0x70, 0xc2, 0xc3, 0x65, 0xf7, 0x25, 0x94, 0x52, 0xf9, 0x98, 0xe1, 0xbe,
-	0x4b, 0x6c, 0x2e, 0x81, 0x10, 0x67, 0x63, 0xb6, 0xae, 0x16, 0x25, 0x06, 0x6f, 0xfb, 0x9d, 0xd1,
-	0x88, 0xda, 0x81, 0x1f, 0xad, 0x6b, 0x88, 0xd7, 0x43, 0x18, 0xdf, 0x86, 0xf5, 0xc0, 0x23, 0xa6,
-	0x35, 0xc5, 0xcd, 0x70, 0x2e, 0x8a, 0x0c, 0x31, 0x79, 0x0f, 0x2e, 0x46, 0x71, 0x0d, 0x1a, 0x10,
-	0xfd, 0x84, 0x1a, 0x13, 0xa7, 0x1c, 0xbf, 0x39, 0xbc, 0x10, 0x12, 0x1a, 0xa1, 0x3d, 0xf2, 0xad,
-	0xfc, 0x23, 0x05, 0xeb, 0xd1, 0x87, 0x8a, 0x11, 0x17, 0xeb, 0x10, 0x80, 0xd8, 0xb6, 0x13, 0x24,
-	0xcb, 0x35, 0x2f, 0xe5, 0x39, 0xbf, 0x6a, 0x2d, 0x76, 0x52, 0x13, 0x01, 0xb6, 0x46, 0x00, 0x13,
-	0xcb, 0xd2, 0xb2, 0x5d, 0x81, 0x62, 0x78, 0x73, 0xcf, 0x7f, 0xfe, 0x11, 0x9f, 0xb6, 0x20, 0x20,
-	0xf6, 0x45, 0x83, 0x37, 0x21, 0x7b, 0x4c, 0x87, 0xa6, 0x1d, 0xde, 0x27, 0x8a, 0x41, 0x74, 0x4b,
-	0x99, 0x89, 0x6f, 0x29, 0xf7, 0x9f, 0xc0, 0x86, 0xee, 0x8c, 0x66, 0xd3, 0xdd, 0x47, 0x33, 0x9f,
-	0xd7, 0xfe, 0xe7, 0xa9, 0x2f, 0x61, 0xd2, 0x62, 0x7e, 0x23, 0xa5, 0x0f, 0xba, 0xfb, 0x7f, 0x92,
-	0xb6, 0x0e, 0x84, 0x5f, 0x37, 0x9a, 0xa6, 0x4a, 0x07, 0x16, 0xd5, 0x59, 0xea, 0xff, 0x0f, 0x00,
-	0x00, 0xff, 0xff, 0xa0, 0xbf, 0x63, 0x15, 0xd3, 0x1a, 0x00, 0x00,
+	// 2451 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xcd, 0x6f, 0xdb, 0xc8,
+	0x15, 0x5f, 0x7d, 0x5a, 0x7a, 0x92, 0xe5, 0xf1, 0xd8, 0x9b, 0x30, 0xce, 0x66, 0xe3, 0x28, 0xc9,
+	0xc6, 0x49, 0x5a, 0x65, 0xe1, 0x7c, 0xae, 0xb7, 0xd8, 0x56, 0x96, 0x18, 0xaf, 0x52, 0x59, 0x52,
+	0x29, 0xb9, 0x9b, 0xec, 0x85, 0x18, 0x93, 0x23, 0x89, 0x09, 0x45, 0x72, 0x49, 0x2a, 0x89, 0x83,
+	0x1e, 0x02, 0xf4, 0xd4, 0xff, 0xa0, 0x28, 0x8a, 0x1e, 0xf6, 0xb2, 0x40, 0xaf, 0x05, 0x0a, 0xb4,
+	0xf7, 0x5e, 0x0b, 0xf4, 0xde, 0x43, 0x0f, 0x05, 0xda, 0x3f, 0xa3, 0x98, 0x19, 0x92, 0xa2, 0xbe,
+	0x12, 0x77, 0x81, 0x64, 0x4f, 0xf6, 0xfc, 0xde, 0xef, 0xbd, 0x79, 0xf3, 0xf8, 0x66, 0xde, 0x9b,
+	0x11, 0x20, 0x9d, 0x7a, 0x9a, 0x6b, 0x38, 0xbe, 0xed, 0x56, 0x1c, 0xd7, 0xf6, 0x6d, 0xbc, 0x36,
+	0xb0, 0xed, 0x81, 0x49, 0xc5, 0xe8, 0x78, 0xdc, 0x2f, 0x1f, 0xc2, 0xfa, 0x43, 0xc3, 0xa4, 0xf5,
+	0x88, 0xd8, 0xa5, 0x3e, 0x7e, 0x00, 0xe9, 0xbe, 0x61, 0x52, 0x29, 0xb1, 0x9d, 0xda, 0x29, 0xec,
+	0x5e, 0xa9, 0xcc, 0x28, 0x55, 0xa6, 0x35, 0x3a, 0x0c, 0x56, 0xb8, 0x46, 0xf9, 0xdf, 0x69, 0xd8,
+	0x58, 0x20, 0xc5, 0x18, 0xd2, 0x16, 0x19, 0x31, 0x8b, 0x89, 0x9d, 0xbc, 0xc2, 0xff, 0xc7, 0x12,
+	0xac, 0x38, 0x44, 0x7b, 0x46, 0x06, 0x54, 0x4a, 0x72, 0x38, 0x1c, 0xe2, 0x8f, 0x01, 0x74, 0xea,
+	0x50, 0x4b, 0xa7, 0x96, 0x76, 0x22, 0xa5, 0xb6, 0x53, 0x3b, 0x79, 0x25, 0x86, 0xe0, 0x9b, 0xb0,
+	0xee, 0x8c, 0x8f, 0x4d, 0x43, 0x53, 0x63, 0x34, 0xd8, 0x4e, 0xed, 0x64, 0x14, 0x24, 0x04, 0xf5,
+	0x09, 0xf9, 0x1a, 0xac, 0xbd, 0xa0, 0xe4, 0x59, 0x9c, 0x5a, 0xe0, 0xd4, 0x12, 0x83, 0x63, 0xc4,
+	0x1a, 0x14, 0x47, 0xd4, 0xf3, 0xc8, 0x80, 0xaa, 0xfe, 0x89, 0x43, 0xa5, 0x34, 0x5f, 0xfd, 0xf6,
+	0xdc, 0xea, 0x67, 0x57, 0x5e, 0x08, 0xb4, 0x7a, 0x27, 0x0e, 0xc5, 0x55, 0xc8, 0x53, 0x6b, 0x3c,
+	0x12, 0x16, 0x32, 0x4b, 0xe2, 0x27, 0x5b, 0xe3, 0xd1, 0xac, 0x95, 0x1c, 0x53, 0x0b, 0x4c, 0xac,
+	0x78, 0xd4, 0x7d, 0x6e, 0x68, 0x54, 0xca, 0x72, 0x03, 0xd7, 0xe6, 0x0c, 0x74, 0x85, 0x7c, 0xd6,
+	0x46, 0xa8, 0x87, 0x6b, 0x90, 0xa7, 0x2f, 0x7d, 0x6a, 0x79, 0x86, 0x6d, 0x49, 0x2b, 0xdc, 0xc8,
+	0xd5, 0x05, 0x5f, 0x91, 0x9a, 0xfa, 0xac, 0x89, 0x89, 0x1e, 0xbe, 0x07, 0x2b, 0xb6, 0xe3, 0x1b,
+	0xb6, 0xe5, 0x49, 0xb9, 0xed, 0xc4, 0x4e, 0x61, 0xf7, 0xa3, 0x85, 0x89, 0xd0, 0x16, 0x1c, 0x25,
+	0x24, 0xe3, 0x06, 0x20, 0xcf, 0x1e, 0xbb, 0x1a, 0x55, 0x35, 0x5b, 0xa7, 0xaa, 0x61, 0xf5, 0x6d,
+	0x29, 0xcf, 0x0d, 0x5c, 0x9c, 0x5f, 0x08, 0x27, 0xd6, 0x6c, 0x9d, 0x36, 0xac, 0xbe, 0xad, 0x94,
+	0xbc, 0xa9, 0x31, 0x3e, 0x03, 0x59, 0xef, 0xc4, 0xf2, 0xc9, 0x4b, 0xa9, 0xc8, 0x33, 0x24, 0x18,
+	0x95, 0xff, 0x92, 0x85, 0xb5, 0xd3, 0xa4, 0xd8, 0xe7, 0x90, 0xe9, 0xb3, 0x55, 0x4a, 0xc9, 0xff,
+	0x27, 0x06, 0x42, 0x67, 0x3a, 0x88, 0xd9, 0xef, 0x19, 0xc4, 0x2a, 0x14, 0x2c, 0xea, 0xf9, 0x54,
+	0x17, 0x19, 0x91, 0x3a, 0x65, 0x4e, 0x81, 0x50, 0x9a, 0x4f, 0xa9, 0xf4, 0xf7, 0x4a, 0xa9, 0xc7,
+	0xb0, 0x16, 0xb9, 0xa4, 0xba, 0xc4, 0x1a, 0x84, 0xb9, 0x79, 0xeb, 0x6d, 0x9e, 0x54, 0xe4, 0x50,
+	0x4f, 0x61, 0x6a, 0x4a, 0x89, 0x4e, 0x8d, 0x71, 0x1d, 0xc0, 0xb6, 0xa8, 0xdd, 0x57, 0x75, 0xaa,
+	0x99, 0x52, 0x6e, 0x49, 0x94, 0xda, 0x8c, 0x32, 0x17, 0x25, 0x5b, 0xa0, 0x9a, 0x89, 0x3f, 0x9b,
+	0xa4, 0xda, 0xca, 0x92, 0x4c, 0x39, 0x14, 0x9b, 0x6c, 0x2e, 0xdb, 0x8e, 0xa0, 0xe4, 0x52, 0x96,
+	0xf7, 0x54, 0x0f, 0x56, 0x96, 0xe7, 0x4e, 0x54, 0xde, 0xba, 0x32, 0x25, 0x50, 0x13, 0x0b, 0x5b,
+	0x75, 0xe3, 0x43, 0x7c, 0x19, 0x22, 0x40, 0xe5, 0x69, 0x05, 0xfc, 0x14, 0x2a, 0x86, 0x60, 0x8b,
+	0x8c, 0xe8, 0xd6, 0x2b, 0x28, 0x4d, 0x87, 0x07, 0x6f, 0x42, 0xc6, 0xf3, 0x89, 0xeb, 0xf3, 0x2c,
+	0xcc, 0x28, 0x62, 0x80, 0x11, 0xa4, 0xa8, 0xa5, 0xf3, 0x53, 0x2e, 0xa3, 0xb0, 0x7f, 0xf1, 0xcf,
+	0x26, 0x0b, 0x4e, 0xf1, 0x05, 0x7f, 0x32, 0xff, 0x45, 0xa7, 0x2c, 0xcf, 0xae, 0x7b, 0xeb, 0x3e,
+	0xac, 0x4e, 0x2d, 0xe0, 0xb4, 0x53, 0x97, 0x7f, 0x05, 0x1f, 0x2e, 0x34, 0x8d, 0x1f, 0xc3, 0xe6,
+	0xd8, 0x32, 0x2c, 0x9f, 0xba, 0x8e, 0x4b, 0x59, 0xc6, 0x8a, 0xa9, 0xa4, 0xff, 0xac, 0x2c, 0xc9,
+	0xb9, 0xa3, 0x38, 0x5b, 0x58, 0x51, 0x36, 0xc6, 0xf3, 0xe0, 0x8d, 0x7c, 0xee, 0xbf, 0x2b, 0xe8,
+	0xf5, 0xeb, 0xd7, 0xaf, 0x93, 0xe5, 0xdf, 0x66, 0x61, 0x73, 0xd1, 0x9e, 0x59, 0xb8, 0x7d, 0xcf,
+	0x40, 0xd6, 0x1a, 0x8f, 0x8e, 0xa9, 0xcb, 0x83, 0x94, 0x51, 0x82, 0x11, 0xae, 0x42, 0xc6, 0x24,
+	0xc7, 0xd4, 0x94, 0xd2, 0xdb, 0x89, 0x9d, 0xd2, 0xee, 0xcd, 0x53, 0xed, 0xca, 0x4a, 0x93, 0xa9,
+	0x28, 0x42, 0x13, 0x7f, 0x01, 0xe9, 0xe0, 0x88, 0x66, 0x16, 0x6e, 0x9c, 0xce, 0x02, 0xdb, 0x4b,
+	0x0a, 0xd7, 0xc3, 0xe7, 0x21, 0xcf, 0xfe, 0x8a, 0xdc, 0xc8, 0x72, 0x9f, 0x73, 0x0c, 0x60, 0x79,
+	0x81, 0xb7, 0x20, 0xc7, 0xb7, 0x89, 0x4e, 0xc3, 0xd2, 0x16, 0x8d, 0x59, 0x62, 0xe9, 0xb4, 0x4f,
+	0xc6, 0xa6, 0xaf, 0x3e, 0x27, 0xe6, 0x98, 0xf2, 0x84, 0xcf, 0x2b, 0xc5, 0x00, 0xfc, 0x25, 0xc3,
+	0xf0, 0x45, 0x28, 0x88, 0x5d, 0x65, 0x58, 0x3a, 0x7d, 0xc9, 0x4f, 0xcf, 0x8c, 0x22, 0x36, 0x5a,
+	0x83, 0x21, 0x6c, 0xfa, 0xa7, 0x9e, 0x6d, 0x85, 0xa9, 0xc9, 0xa7, 0x60, 0x00, 0x9f, 0xfe, 0xfe,
+	0xec, 0xc1, 0x7d, 0x61, 0xf1, 0xf2, 0x66, 0x73, 0xaa, 0xfc, 0xe7, 0x24, 0xa4, 0xf9, 0x79, 0xb1,
+	0x06, 0x85, 0xde, 0x93, 0x8e, 0xac, 0xd6, 0xdb, 0x47, 0xfb, 0x4d, 0x19, 0x25, 0x70, 0x09, 0x80,
+	0x03, 0x0f, 0x9b, 0xed, 0x6a, 0x0f, 0x25, 0xa3, 0x71, 0xa3, 0xd5, 0xbb, 0x77, 0x07, 0xa5, 0x22,
+	0x85, 0x23, 0x01, 0xa4, 0xe3, 0x84, 0xdb, 0xbb, 0x28, 0x83, 0x11, 0x14, 0x85, 0x81, 0xc6, 0x63,
+	0xb9, 0x7e, 0xef, 0x0e, 0xca, 0x4e, 0x23, 0xb7, 0x77, 0xd1, 0x0a, 0x5e, 0x85, 0x3c, 0x47, 0xf6,
+	0xdb, 0xed, 0x26, 0xca, 0x45, 0x36, 0xbb, 0x3d, 0xa5, 0xd1, 0x3a, 0x40, 0xf9, 0xc8, 0xe6, 0x81,
+	0xd2, 0x3e, 0xea, 0x20, 0x88, 0x2c, 0x1c, 0xca, 0xdd, 0x6e, 0xf5, 0x40, 0x46, 0x85, 0x88, 0xb1,
+	0xff, 0xa4, 0x27, 0x77, 0x51, 0x71, 0xca, 0xad, 0xdb, 0xbb, 0x68, 0x35, 0x9a, 0x42, 0x6e, 0x1d,
+	0x1d, 0xa2, 0x12, 0x5e, 0x87, 0x55, 0x31, 0x45, 0xe8, 0xc4, 0xda, 0x0c, 0x74, 0xef, 0x0e, 0x42,
+	0x13, 0x47, 0x84, 0x95, 0xf5, 0x29, 0xe0, 0xde, 0x1d, 0x84, 0xcb, 0x35, 0xc8, 0xf0, 0xec, 0xc2,
+	0x18, 0x4a, 0xcd, 0xea, 0xbe, 0xdc, 0x54, 0xdb, 0x9d, 0x5e, 0xa3, 0xdd, 0xaa, 0x36, 0x51, 0x62,
+	0x82, 0x29, 0xf2, 0x2f, 0x8e, 0x1a, 0x8a, 0x5c, 0x47, 0xc9, 0x38, 0xd6, 0x91, 0xab, 0x3d, 0xb9,
+	0x8e, 0x52, 0x65, 0x0d, 0x36, 0x17, 0x9d, 0x93, 0x0b, 0x77, 0x46, 0xec, 0x13, 0x27, 0x97, 0x7c,
+	0x62, 0x6e, 0x6b, 0xee, 0x13, 0x7f, 0x9b, 0x80, 0x8d, 0x05, 0xb5, 0x62, 0xe1, 0x24, 0x3f, 0x85,
+	0x8c, 0x48, 0x51, 0x51, 0x3d, 0xaf, 0x2f, 0x2c, 0x3a, 0x3c, 0x61, 0xe7, 0x2a, 0x28, 0xd7, 0x8b,
+	0x77, 0x10, 0xa9, 0x25, 0x1d, 0x04, 0x33, 0x31, 0xe7, 0xe4, 0xaf, 0x13, 0x20, 0x2d, 0xb3, 0xfd,
+	0x96, 0x83, 0x22, 0x39, 0x75, 0x50, 0x7c, 0x3e, 0xeb, 0xc0, 0xa5, 0xe5, 0x6b, 0x98, 0xf3, 0xe2,
+	0xbb, 0x04, 0x9c, 0x59, 0xdc, 0x68, 0x2d, 0xf4, 0xe1, 0x0b, 0xc8, 0x8e, 0xa8, 0x3f, 0xb4, 0xc3,
+	0x66, 0xe3, 0x93, 0x05, 0x25, 0x8c, 0x89, 0x67, 0x63, 0x15, 0x68, 0xc5, 0x6b, 0x60, 0x6a, 0x59,
+	0xb7, 0x24, 0xbc, 0x99, 0xf3, 0xf4, 0x37, 0x49, 0xf8, 0x70, 0xa1, 0xf1, 0x85, 0x8e, 0x5e, 0x00,
+	0x30, 0x2c, 0x67, 0xec, 0x8b, 0x86, 0x42, 0x9c, 0x4f, 0x79, 0x8e, 0xf0, 0xbd, 0xcf, 0xce, 0x9e,
+	0xb1, 0x1f, 0xc9, 0x53, 0x5c, 0x0e, 0x02, 0xe2, 0x84, 0x07, 0x13, 0x47, 0xd3, 0xdc, 0xd1, 0x8f,
+	0x97, 0xac, 0x74, 0xae, 0x56, 0x7f, 0x0a, 0x48, 0x33, 0x0d, 0x6a, 0xf9, 0xaa, 0xe7, 0xbb, 0x94,
+	0x8c, 0x0c, 0x6b, 0xc0, 0x0f, 0xe0, 0xdc, 0x5e, 0xa6, 0x4f, 0x4c, 0x8f, 0x2a, 0x6b, 0x42, 0xdc,
+	0x0d, 0xa5, 0x4c, 0x83, 0xd7, 0x38, 0x37, 0xa6, 0x91, 0x9d, 0xd2, 0x10, 0xe2, 0x48, 0xa3, 0xfc,
+	0xa7, 0x1c, 0x14, 0x62, 0x6d, 0x29, 0xbe, 0x04, 0xc5, 0xa7, 0xe4, 0x39, 0x51, 0xc3, 0xab, 0x86,
+	0x88, 0x44, 0x81, 0x61, 0x9d, 0xe0, 0xba, 0xf1, 0x29, 0x6c, 0x72, 0x8a, 0x3d, 0xf6, 0xa9, 0xab,
+	0x6a, 0x26, 0xf1, 0x3c, 0x1e, 0xb4, 0x1c, 0xa7, 0x62, 0x26, 0x6b, 0x33, 0x51, 0x2d, 0x94, 0xe0,
+	0xbb, 0xb0, 0xc1, 0x35, 0x46, 0x63, 0xd3, 0x37, 0x1c, 0x93, 0xaa, 0xec, 0xf2, 0xe3, 0xf1, 0x83,
+	0x38, 0xf2, 0x6c, 0x9d, 0x31, 0x0e, 0x03, 0x02, 0xf3, 0xc8, 0xc3, 0x75, 0xb8, 0xc0, 0xd5, 0x06,
+	0xd4, 0xa2, 0x2e, 0xf1, 0xa9, 0x4a, 0xbf, 0x19, 0x13, 0xd3, 0x53, 0x89, 0xa5, 0xab, 0x43, 0xe2,
+	0x0d, 0xa5, 0x4d, 0x66, 0x60, 0x3f, 0x29, 0x25, 0x94, 0x73, 0x8c, 0x78, 0x10, 0xf0, 0x64, 0x4e,
+	0xab, 0x5a, 0xfa, 0x97, 0xc4, 0x1b, 0xe2, 0x3d, 0x38, 0xc3, 0xad, 0x78, 0xbe, 0x6b, 0x58, 0x03,
+	0x55, 0x1b, 0x52, 0xed, 0x99, 0x3a, 0xf6, 0xfb, 0x0f, 0xa4, 0xf3, 0xf1, 0xf9, 0xb9, 0x87, 0x5d,
+	0xce, 0xa9, 0x31, 0xca, 0x91, 0xdf, 0x7f, 0x80, 0xbb, 0x50, 0x64, 0x1f, 0x63, 0x64, 0xbc, 0xa2,
+	0x6a, 0xdf, 0x76, 0x79, 0x65, 0x29, 0x2d, 0xd8, 0xd9, 0xb1, 0x08, 0x56, 0xda, 0x81, 0xc2, 0xa1,
+	0xad, 0xd3, 0xbd, 0x4c, 0xb7, 0x23, 0xcb, 0x75, 0xa5, 0x10, 0x5a, 0x79, 0x68, 0xbb, 0x2c, 0xa1,
+	0x06, 0x76, 0x14, 0xe0, 0x82, 0x48, 0xa8, 0x81, 0x1d, 0x86, 0xf7, 0x2e, 0x6c, 0x68, 0x9a, 0x58,
+	0xb3, 0xa1, 0xa9, 0xc1, 0x15, 0xc5, 0x93, 0xd0, 0x54, 0xb0, 0x34, 0xed, 0x40, 0x10, 0x82, 0x1c,
+	0xf7, 0xf0, 0x67, 0xf0, 0xe1, 0x24, 0x58, 0x71, 0xc5, 0xf5, 0xb9, 0x55, 0xce, 0xaa, 0xde, 0x85,
+	0x0d, 0xe7, 0x64, 0x5e, 0x11, 0x4f, 0xcd, 0xe8, 0x9c, 0xcc, 0xaa, 0xdd, 0x87, 0x4d, 0x67, 0xe8,
+	0xcc, 0xeb, 0x6d, 0xc4, 0xf5, 0xb0, 0x33, 0x74, 0x66, 0x15, 0xaf, 0xf2, 0xfb, 0xaa, 0x4b, 0x35,
+	0xe2, 0x53, 0x5d, 0x3a, 0x1b, 0xa7, 0xc7, 0x04, 0xf8, 0x16, 0x20, 0x4d, 0x53, 0xa9, 0x45, 0x8e,
+	0x4d, 0xaa, 0x12, 0x97, 0x5a, 0xc4, 0x93, 0x2e, 0xc6, 0xc9, 0x25, 0x4d, 0x93, 0xb9, 0xb4, 0xca,
+	0x85, 0xf8, 0x06, 0xac, 0xdb, 0xc7, 0x4f, 0x35, 0x91, 0x92, 0xaa, 0xe3, 0xd2, 0xbe, 0xf1, 0x52,
+	0xba, 0xc2, 0xe3, 0xbb, 0xc6, 0x04, 0x3c, 0x21, 0x3b, 0x1c, 0xc6, 0xd7, 0x01, 0x69, 0xde, 0x90,
+	0xb8, 0x0e, 0xef, 0x09, 0x3c, 0x87, 0x68, 0x54, 0xba, 0x2a, 0xa8, 0x02, 0x6f, 0x85, 0x30, 0xdb,
+	0x12, 0xde, 0x0b, 0xa3, 0xef, 0x87, 0x16, 0xaf, 0x89, 0x2d, 0xc1, 0xb1, 0xc0, 0xda, 0x0e, 0x20,
+	0x16, 0x8a, 0xa9, 0x89, 0x77, 0x38, 0xad, 0xe4, 0x0c, 0x9d, 0xf8, 0xbc, 0x97, 0x61, 0x95, 0x31,
+	0x27, 0x93, 0x5e, 0x17, 0xfd, 0x8c, 0x33, 0x8c, 0xcd, 0xf8, 0xce, 0x5a, 0xcb, 0xf2, 0x1e, 0x14,
+	0xe3, 0xf9, 0x89, 0xf3, 0x20, 0x32, 0x14, 0x25, 0x58, 0xad, 0xaf, 0xb5, 0xeb, 0xac, 0x4a, 0x7f,
+	0x2d, 0xa3, 0x24, 0xeb, 0x16, 0x9a, 0x8d, 0x9e, 0xac, 0x2a, 0x47, 0xad, 0x5e, 0xe3, 0x50, 0x46,
+	0xa9, 0x78, 0x5b, 0xfa, 0xb7, 0x24, 0x94, 0xa6, 0x6f, 0x18, 0xf8, 0x27, 0x70, 0x36, 0x7c, 0x0e,
+	0xf0, 0xa8, 0xaf, 0xbe, 0x30, 0x5c, 0xbe, 0x65, 0x46, 0x44, 0x74, 0xd8, 0xd1, 0x47, 0xdb, 0x0c,
+	0x58, 0x5d, 0xea, 0x7f, 0x65, 0xb8, 0x6c, 0x43, 0x8c, 0x88, 0x8f, 0x9b, 0x70, 0xd1, 0xb2, 0x55,
+	0xcf, 0x27, 0x96, 0x4e, 0x5c, 0x5d, 0x9d, 0x3c, 0xc4, 0xa8, 0x44, 0xd3, 0xa8, 0xe7, 0xd9, 0xa2,
+	0x54, 0x45, 0x56, 0x3e, 0xb2, 0xec, 0x6e, 0x40, 0x9e, 0x9c, 0xe1, 0xd5, 0x80, 0x3a, 0x93, 0x60,
+	0xa9, 0x65, 0x09, 0x76, 0x1e, 0xf2, 0x23, 0xe2, 0xa8, 0xd4, 0xf2, 0xdd, 0x13, 0xde, 0x57, 0xe6,
+	0x94, 0xdc, 0x88, 0x38, 0x32, 0x1b, 0xbf, 0x9f, 0xf6, 0xfe, 0x9f, 0x29, 0x28, 0xc6, 0x7b, 0x4b,
+	0xd6, 0xaa, 0x6b, 0xbc, 0x8e, 0x24, 0xf8, 0x49, 0x73, 0xf9, 0x8d, 0x9d, 0x68, 0xa5, 0xc6, 0x0a,
+	0xcc, 0x5e, 0x56, 0x74, 0x7c, 0x8a, 0xd0, 0x64, 0xc5, 0x9d, 0x9d, 0x2d, 0x54, 0xdc, 0x62, 0x72,
+	0x4a, 0x30, 0xc2, 0x07, 0x90, 0x7d, 0xea, 0x71, 0xdb, 0x59, 0x6e, 0xfb, 0xca, 0x9b, 0x6d, 0x3f,
+	0xea, 0x72, 0xe3, 0xf9, 0x47, 0x5d, 0xb5, 0xd5, 0x56, 0x0e, 0xab, 0x4d, 0x25, 0x50, 0xc7, 0xe7,
+	0x20, 0x6d, 0x92, 0x57, 0x27, 0xd3, 0xa5, 0x88, 0x43, 0xa7, 0x0d, 0xfc, 0x39, 0x48, 0xbf, 0xa0,
+	0xe4, 0xd9, 0x74, 0x01, 0xe0, 0xd0, 0x3b, 0x4c, 0xfd, 0x5b, 0x90, 0xe1, 0xf1, 0xc2, 0x00, 0x41,
+	0xc4, 0xd0, 0x07, 0x38, 0x07, 0xe9, 0x5a, 0x5b, 0x61, 0xe9, 0x8f, 0xa0, 0x28, 0x50, 0xb5, 0xd3,
+	0x90, 0x6b, 0x32, 0x4a, 0x96, 0xef, 0x42, 0x56, 0x04, 0x81, 0x6d, 0x8d, 0x28, 0x0c, 0xe8, 0x83,
+	0x60, 0x18, 0xd8, 0x48, 0x84, 0xd2, 0xa3, 0xc3, 0x7d, 0x59, 0x41, 0xc9, 0xf8, 0xe7, 0xf5, 0xa0,
+	0x18, 0x6f, 0x2b, 0xdf, 0x4f, 0x4e, 0xfd, 0x35, 0x01, 0x85, 0x58, 0x9b, 0xc8, 0x1a, 0x14, 0x62,
+	0x9a, 0xf6, 0x0b, 0x95, 0x98, 0x06, 0xf1, 0x82, 0xa4, 0x00, 0x0e, 0x55, 0x19, 0x72, 0xda, 0x8f,
+	0xf6, 0x5e, 0x9c, 0xff, 0x43, 0x02, 0xd0, 0x6c, 0x8b, 0x39, 0xe3, 0x60, 0xe2, 0x07, 0x75, 0xf0,
+	0xf7, 0x09, 0x28, 0x4d, 0xf7, 0x95, 0x33, 0xee, 0x5d, 0xfa, 0x41, 0xdd, 0xfb, 0x57, 0x12, 0x56,
+	0xa7, 0xba, 0xc9, 0xd3, 0x7a, 0xf7, 0x0d, 0xac, 0x1b, 0x3a, 0x1d, 0x39, 0xb6, 0x4f, 0x2d, 0xed,
+	0x44, 0x35, 0xe9, 0x73, 0x6a, 0x4a, 0x65, 0x7e, 0x50, 0xdc, 0x7a, 0x73, 0xbf, 0x5a, 0x69, 0x4c,
+	0xf4, 0x9a, 0x4c, 0x6d, 0x6f, 0xa3, 0x51, 0x97, 0x0f, 0x3b, 0xed, 0x9e, 0xdc, 0xaa, 0x3d, 0x51,
+	0x8f, 0x5a, 0x3f, 0x6f, 0xb5, 0xbf, 0x6a, 0x29, 0xc8, 0x98, 0xa1, 0xbd, 0xc3, 0xad, 0xde, 0x01,
+	0x34, 0xeb, 0x14, 0x3e, 0x0b, 0x8b, 0xdc, 0x42, 0x1f, 0xe0, 0x0d, 0x58, 0x6b, 0xb5, 0xd5, 0x6e,
+	0xa3, 0x2e, 0xab, 0xf2, 0xc3, 0x87, 0x72, 0xad, 0xd7, 0x15, 0x17, 0xf8, 0x88, 0xdd, 0x9b, 0xde,
+	0xd4, 0xbf, 0x4b, 0xc1, 0xc6, 0x02, 0x4f, 0x70, 0x35, 0xb8, 0x3b, 0x88, 0xeb, 0xcc, 0x8f, 0x4f,
+	0xe3, 0x7d, 0x85, 0x95, 0xfc, 0x0e, 0x71, 0xfd, 0xe0, 0xaa, 0x71, 0x1d, 0x58, 0x94, 0x2c, 0xdf,
+	0xe8, 0x1b, 0xd4, 0x0d, 0xde, 0x3b, 0xc4, 0x85, 0x62, 0x6d, 0x82, 0x8b, 0x27, 0x8f, 0x1f, 0x01,
+	0x76, 0x6c, 0xcf, 0xf0, 0x8d, 0xe7, 0x54, 0x35, 0xac, 0xf0, 0x71, 0x84, 0x5d, 0x30, 0xd2, 0x0a,
+	0x0a, 0x25, 0x0d, 0xcb, 0x8f, 0xd8, 0x16, 0x1d, 0x90, 0x19, 0x36, 0x3b, 0xc0, 0x53, 0x0a, 0x0a,
+	0x25, 0x11, 0xfb, 0x12, 0x14, 0x75, 0x7b, 0xcc, 0xba, 0x2e, 0xc1, 0x63, 0xf5, 0x22, 0xa1, 0x14,
+	0x04, 0x16, 0x51, 0x82, 0x7e, 0x7a, 0xf2, 0x2a, 0x53, 0x54, 0x0a, 0x02, 0x13, 0x94, 0x6b, 0xb0,
+	0x46, 0x06, 0x03, 0x97, 0x19, 0x0f, 0x0d, 0x89, 0x1b, 0x42, 0x29, 0x82, 0x39, 0x71, 0xeb, 0x11,
+	0xe4, 0xc2, 0x38, 0xb0, 0x92, 0xcc, 0x22, 0xa1, 0x3a, 0xe2, 0x65, 0x2e, 0xb9, 0x93, 0x57, 0x72,
+	0x56, 0x28, 0xbc, 0x04, 0x45, 0xc3, 0x53, 0x27, 0x8f, 0xcc, 0xc9, 0xed, 0xe4, 0x4e, 0x4e, 0x29,
+	0x18, 0x5e, 0xf4, 0x40, 0x57, 0xfe, 0x2e, 0x09, 0xa5, 0xe9, 0x47, 0x72, 0x5c, 0x87, 0x9c, 0x69,
+	0x6b, 0x84, 0xa7, 0x96, 0xf8, 0x85, 0x66, 0xe7, 0x2d, 0xef, 0xea, 0x95, 0x66, 0xc0, 0x57, 0x22,
+	0xcd, 0xad, 0xbf, 0x27, 0x20, 0x17, 0xc2, 0xf8, 0x0c, 0xa4, 0x1d, 0xe2, 0x0f, 0xb9, 0xb9, 0xcc,
+	0x7e, 0x12, 0x25, 0x14, 0x3e, 0x66, 0xb8, 0xe7, 0x10, 0x8b, 0xa7, 0x40, 0x80, 0xb3, 0x31, 0xfb,
+	0xae, 0x26, 0x25, 0x3a, 0xbf, 0x7e, 0xd8, 0xa3, 0x11, 0xb5, 0x7c, 0x2f, 0xfc, 0xae, 0x01, 0x5e,
+	0x0b, 0x60, 0x7c, 0x13, 0xd6, 0x7d, 0x97, 0x18, 0xe6, 0x14, 0x37, 0xcd, 0xb9, 0x28, 0x14, 0x44,
+	0xe4, 0x3d, 0x38, 0x17, 0xda, 0xd5, 0xa9, 0x4f, 0xb4, 0x21, 0xd5, 0x27, 0x4a, 0x59, 0xfe, 0x02,
+	0x7b, 0x36, 0x20, 0xd4, 0x03, 0x79, 0xa8, 0x5b, 0xfe, 0x47, 0x02, 0xd6, 0xc3, 0x0b, 0x93, 0x1e,
+	0x05, 0xeb, 0x10, 0x80, 0x58, 0x96, 0xed, 0xc7, 0xc3, 0x35, 0x9f, 0xca, 0x73, 0x7a, 0x95, 0x6a,
+	0xa4, 0xa4, 0xc4, 0x0c, 0x6c, 0x8d, 0x00, 0x26, 0x92, 0xa5, 0x61, 0xbb, 0x08, 0x85, 0xe0, 0x17,
+	0x10, 0xfe, 0x33, 0x9a, 0xb8, 0x62, 0x83, 0x80, 0xd8, 0xcd, 0x0a, 0x6f, 0x42, 0xe6, 0x98, 0x0e,
+	0x0c, 0x2b, 0x78, 0xd7, 0x14, 0x83, 0xf0, 0xad, 0x36, 0x1d, 0xbd, 0xd5, 0xee, 0x3f, 0x86, 0x0d,
+	0xcd, 0x1e, 0xcd, 0xba, 0xbb, 0x8f, 0x66, 0xae, 0xf9, 0xde, 0x97, 0x89, 0xaf, 0x61, 0xd2, 0x62,
+	0x7e, 0x9b, 0x4c, 0x1d, 0x74, 0xf6, 0xff, 0x98, 0xdc, 0x3a, 0x10, 0x7a, 0x9d, 0x70, 0x99, 0x0a,
+	0xed, 0x9b, 0x54, 0x63, 0xae, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x6b, 0x03, 0xf1, 0x99, 0x1b,
+	0x1c, 0x00, 0x00,
 }
diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go
index bac9913e019..be534f0fa1c 100644
--- a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go
+++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: descriptor.proto
-// DO NOT EDIT!
 
 /*
 Package descriptor is a generated protocol buffer package.
@@ -12,6 +11,7 @@ It has these top-level messages:
 	FileDescriptorSet
 	FileDescriptorProto
 	DescriptorProto
+	ExtensionRangeOptions
 	FieldDescriptorProto
 	OneofDescriptorProto
 	EnumDescriptorProto
@@ -155,7 +155,7 @@ func (this *DescriptorProto_ExtensionRange) GoString() string {
 	if this == nil {
 		return "nil"
 	}
-	s := make([]string, 0, 6)
+	s := make([]string, 0, 7)
 	s = append(s, "&descriptor.DescriptorProto_ExtensionRange{")
 	if this.Start != nil {
 		s = append(s, "Start: "+valueToGoStringDescriptor(this.Start, "int32")+",\n")
@@ -163,6 +163,9 @@ func (this *DescriptorProto_ExtensionRange) GoString() string {
 	if this.End != nil {
 		s = append(s, "End: "+valueToGoStringDescriptor(this.End, "int32")+",\n")
 	}
+	if this.Options != nil {
+		s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n")
+	}
 	if this.XXX_unrecognized != nil {
 		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
 	}
@@ -187,6 +190,22 @@ func (this *DescriptorProto_ReservedRange) GoString() string {
 	s = append(s, "}")
 	return strings.Join(s, "")
 }
+func (this *ExtensionRangeOptions) GoString() string {
+	if this == nil {
+		return "nil"
+	}
+	s := make([]string, 0, 5)
+	s = append(s, "&descriptor.ExtensionRangeOptions{")
+	if this.UninterpretedOption != nil {
+		s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n")
+	}
+	s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n")
+	if this.XXX_unrecognized != nil {
+		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
+	}
+	s = append(s, "}")
+	return strings.Join(s, "")
+}
 func (this *FieldDescriptorProto) GoString() string {
 	if this == nil {
 		return "nil"
@@ -200,10 +219,10 @@ func (this *FieldDescriptorProto) GoString() string {
 		s = append(s, "Number: "+valueToGoStringDescriptor(this.Number, "int32")+",\n")
 	}
 	if this.Label != nil {
-		s = append(s, "Label: "+valueToGoStringDescriptor(this.Label, "descriptor.FieldDescriptorProto_Label")+",\n")
+		s = append(s, "Label: "+valueToGoStringDescriptor(this.Label, "FieldDescriptorProto_Label")+",\n")
 	}
 	if this.Type != nil {
-		s = append(s, "Type: "+valueToGoStringDescriptor(this.Type, "descriptor.FieldDescriptorProto_Type")+",\n")
+		s = append(s, "Type: "+valueToGoStringDescriptor(this.Type, "FieldDescriptorProto_Type")+",\n")
 	}
 	if this.TypeName != nil {
 		s = append(s, "TypeName: "+valueToGoStringDescriptor(this.TypeName, "string")+",\n")
@@ -344,7 +363,7 @@ func (this *FileOptions) GoString() string {
 	if this == nil {
 		return "nil"
 	}
-	s := make([]string, 0, 20)
+	s := make([]string, 0, 23)
 	s = append(s, "&descriptor.FileOptions{")
 	if this.JavaPackage != nil {
 		s = append(s, "JavaPackage: "+valueToGoStringDescriptor(this.JavaPackage, "string")+",\n")
@@ -362,7 +381,7 @@ func (this *FileOptions) GoString() string {
 		s = append(s, "JavaStringCheckUtf8: "+valueToGoStringDescriptor(this.JavaStringCheckUtf8, "bool")+",\n")
 	}
 	if this.OptimizeFor != nil {
-		s = append(s, "OptimizeFor: "+valueToGoStringDescriptor(this.OptimizeFor, "descriptor.FileOptions_OptimizeMode")+",\n")
+		s = append(s, "OptimizeFor: "+valueToGoStringDescriptor(this.OptimizeFor, "FileOptions_OptimizeMode")+",\n")
 	}
 	if this.GoPackage != nil {
 		s = append(s, "GoPackage: "+valueToGoStringDescriptor(this.GoPackage, "string")+",\n")
@@ -376,6 +395,9 @@ func (this *FileOptions) GoString() string {
 	if this.PyGenericServices != nil {
 		s = append(s, "PyGenericServices: "+valueToGoStringDescriptor(this.PyGenericServices, "bool")+",\n")
 	}
+	if this.PhpGenericServices != nil {
+		s = append(s, "PhpGenericServices: "+valueToGoStringDescriptor(this.PhpGenericServices, "bool")+",\n")
+	}
 	if this.Deprecated != nil {
 		s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n")
 	}
@@ -391,6 +413,12 @@ func (this *FileOptions) GoString() string {
 	if this.SwiftPrefix != nil {
 		s = append(s, "SwiftPrefix: "+valueToGoStringDescriptor(this.SwiftPrefix, "string")+",\n")
 	}
+	if this.PhpClassPrefix != nil {
+		s = append(s, "PhpClassPrefix: "+valueToGoStringDescriptor(this.PhpClassPrefix, "string")+",\n")
+	}
+	if this.PhpNamespace != nil {
+		s = append(s, "PhpNamespace: "+valueToGoStringDescriptor(this.PhpNamespace, "string")+",\n")
+	}
 	if this.UninterpretedOption != nil {
 		s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n")
 	}
@@ -436,13 +464,13 @@ func (this *FieldOptions) GoString() string {
 	s := make([]string, 0, 11)
 	s = append(s, "&descriptor.FieldOptions{")
 	if this.Ctype != nil {
-		s = append(s, "Ctype: "+valueToGoStringDescriptor(this.Ctype, "descriptor.FieldOptions_CType")+",\n")
+		s = append(s, "Ctype: "+valueToGoStringDescriptor(this.Ctype, "FieldOptions_CType")+",\n")
 	}
 	if this.Packed != nil {
 		s = append(s, "Packed: "+valueToGoStringDescriptor(this.Packed, "bool")+",\n")
 	}
 	if this.Jstype != nil {
-		s = append(s, "Jstype: "+valueToGoStringDescriptor(this.Jstype, "descriptor.FieldOptions_JSType")+",\n")
+		s = append(s, "Jstype: "+valueToGoStringDescriptor(this.Jstype, "FieldOptions_JSType")+",\n")
 	}
 	if this.Lazy != nil {
 		s = append(s, "Lazy: "+valueToGoStringDescriptor(this.Lazy, "bool")+",\n")
@@ -549,7 +577,7 @@ func (this *MethodOptions) GoString() string {
 		s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n")
 	}
 	if this.IdempotencyLevel != nil {
-		s = append(s, "IdempotencyLevel: "+valueToGoStringDescriptor(this.IdempotencyLevel, "descriptor.MethodOptions_IdempotencyLevel")+",\n")
+		s = append(s, "IdempotencyLevel: "+valueToGoStringDescriptor(this.IdempotencyLevel, "MethodOptions_IdempotencyLevel")+",\n")
 	}
 	if this.UninterpretedOption != nil {
 		s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n")
diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/generator/generator.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/generator/generator.go
index a40dda2333c..9a94c19beed 100644
--- a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/generator/generator.go
+++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/generator/generator.go
@@ -1321,9 +1321,8 @@ func (g *Generator) generate(file *FileDescriptor) {
 
 // Generate the header, including package definition
 func (g *Generator) generateHeader() {
-	g.P("// Code generated by protoc-gen-gogo.")
+	g.P("// Code generated by protoc-gen-gogo. DO NOT EDIT.")
 	g.P("// source: ", *g.file.Name)
-	g.P("// DO NOT EDIT!")
 	g.P()
 
 	name := g.file.PackageName()
@@ -2211,6 +2210,15 @@ func (g *Generator) generateMessage(message *Descriptor) {
 		}
 		g.Out()
 		g.P("}")
+	} else {
+		// Even if the type does not need to be generated, we need to iterate
+		// over all its fields to be able to mark as used any imported types
+		// used by those fields.
+		for _, field := range message.Field {
+			if !gogoproto.IsStdTime(field) && !gogoproto.IsStdDuration(field) {
+				g.RecordTypeUse(field.GetTypeName())
+			}
+		}
 	}
 
 	// Update g.Buffer to list valid oneof types.
diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/plugin/plugin.pb.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/plugin/plugin.pb.go
index 0f9f059caf7..c673d503558 100644
--- a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/plugin/plugin.pb.go
+++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/plugin/plugin.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: plugin.proto
-// DO NOT EDIT!
 
 /*
 Package plugin_go is a generated protocol buffer package.
@@ -94,6 +93,9 @@ type CodeGeneratorRequest struct {
 	// the entire set into memory at once.  However, as of this writing, this
 	// is not similarly optimized on protoc's end -- it will store all fields in
 	// memory at once before sending them to the plugin.
+	//
+	// Type names of fields and extensions in the FileDescriptorProto are always
+	// fully qualified.
 	ProtoFile []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file,json=protoFile" json:"proto_file,omitempty"`
 	// The version number of protocol compiler.
 	CompilerVersion  *Version `protobuf:"bytes,3,opt,name=compiler_version,json=compilerVersion" json:"compiler_version,omitempty"`
diff --git a/vendor/github.com/gogo/protobuf/types/any.go b/vendor/github.com/gogo/protobuf/types/any.go
index c10caf40557..d83c3ad0076 100644
--- a/vendor/github.com/gogo/protobuf/types/any.go
+++ b/vendor/github.com/gogo/protobuf/types/any.go
@@ -50,6 +50,9 @@ const googleApis = "type.googleapis.com/"
 // function. AnyMessageName is provided for less common use cases like filtering a
 // sequence of Any messages based on a set of allowed message type names.
 func AnyMessageName(any *Any) (string, error) {
+	if any == nil {
+		return "", fmt.Errorf("message is nil")
+	}
 	slash := strings.LastIndex(any.TypeUrl, "/")
 	if slash < 0 {
 		return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl)
diff --git a/vendor/github.com/gogo/protobuf/types/any.pb.go b/vendor/github.com/gogo/protobuf/types/any.pb.go
index 902d6d62aae..017d8de4d81 100644
--- a/vendor/github.com/gogo/protobuf/types/any.pb.go
+++ b/vendor/github.com/gogo/protobuf/types/any.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: any.proto
-// DO NOT EDIT!
 
 /*
 	Package types is a generated protocol buffer package.
@@ -70,6 +69,16 @@ const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
 //       any.Unpack(foo)
 //       ...
 //
+//  Example 4: Pack and unpack a message in Go
+//
+//      foo := &pb.Foo{...}
+//      any, err := ptypes.MarshalAny(foo)
+//      ...
+//      foo := &pb.Foo{}
+//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+//        ...
+//      }
+//
 // The pack methods provided by protobuf library will by default use
 // 'type.googleapis.com/full.type.name' as the type URL and the unpack
 // methods only use the fully qualified type name after the last '/'
@@ -273,24 +282,6 @@ func (m *Any) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Any(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Any(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintAny(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/gogo/protobuf/types/duration.pb.go b/vendor/github.com/gogo/protobuf/types/duration.pb.go
index 9d7fa8f3130..806d6d8de52 100644
--- a/vendor/github.com/gogo/protobuf/types/duration.pb.go
+++ b/vendor/github.com/gogo/protobuf/types/duration.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: duration.proto
-// DO NOT EDIT!
 
 /*
 	Package types is a generated protocol buffer package.
@@ -40,6 +39,8 @@ const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
 // two Timestamp values is a Duration and it can be added or subtracted
 // from a Timestamp. Range is approximately +-10,000 years.
 //
+// # Examples
+//
 // Example 1: Compute Duration from two Timestamps in pseudo code.
 //
 //     Timestamp start = ...;
@@ -80,10 +81,21 @@ const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
 //     duration = Duration()
 //     duration.FromTimedelta(td)
 //
+// # JSON Mapping
+//
+// In JSON format, the Duration type is encoded as a string rather than an
+// object, where the string ends in the suffix "s" (indicating seconds) and
+// is preceded by the number of seconds, with nanoseconds expressed as
+// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+// microsecond should be expressed in JSON format as "3.000001s".
+//
 //
 type Duration struct {
 	// Signed seconds of the span of time. Must be from -315,576,000,000
-	// to +315,576,000,000 inclusive.
+	// to +315,576,000,000 inclusive. Note: these bounds are computed from:
+	// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
 	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
 	// Signed fractions of a second at nanosecond resolution of the span
 	// of time. Durations less than one second are represented with a 0
@@ -235,24 +247,6 @@ func (m *Duration) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Duration(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Duration(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintDuration(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/gogo/protobuf/types/empty.pb.go b/vendor/github.com/gogo/protobuf/types/empty.pb.go
index 4cfac13261a..1289ac237cb 100644
--- a/vendor/github.com/gogo/protobuf/types/empty.pb.go
+++ b/vendor/github.com/gogo/protobuf/types/empty.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: empty.proto
-// DO NOT EDIT!
 
 /*
 Package types is a generated protocol buffer package.
@@ -142,24 +141,6 @@ func (m *Empty) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Empty(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Empty(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintEmpty(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/gogo/protobuf/types/field_mask.pb.go b/vendor/github.com/gogo/protobuf/types/field_mask.pb.go
index 3bf0ff36999..af684101a91 100644
--- a/vendor/github.com/gogo/protobuf/types/field_mask.pb.go
+++ b/vendor/github.com/gogo/protobuf/types/field_mask.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: field_mask.proto
-// DO NOT EDIT!
 
 /*
 Package types is a generated protocol buffer package.
@@ -380,24 +379,6 @@ func (m *FieldMask) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64FieldMask(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32FieldMask(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintFieldMask(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/gogo/protobuf/types/struct.pb.go b/vendor/github.com/gogo/protobuf/types/struct.pb.go
index 366ea48e747..aec2117d5fd 100644
--- a/vendor/github.com/gogo/protobuf/types/struct.pb.go
+++ b/vendor/github.com/gogo/protobuf/types/struct.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: struct.proto
-// DO NOT EDIT!
 
 /*
 	Package types is a generated protocol buffer package.
@@ -25,6 +24,8 @@ import strings "strings"
 import reflect "reflect"
 import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
 
+import encoding_binary "encoding/binary"
+
 import io "io"
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -828,7 +829,8 @@ func (m *Value_NumberValue) MarshalTo(dAtA []byte) (int, error) {
 	i := 0
 	dAtA[i] = 0x11
 	i++
-	i = encodeFixed64Struct(dAtA, i, uint64(math.Float64bits(float64(m.NumberValue))))
+	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.NumberValue))))
+	i += 8
 	return i, nil
 }
 func (m *Value_StringValue) MarshalTo(dAtA []byte) (int, error) {
@@ -909,24 +911,6 @@ func (m *ListValue) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Struct(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Struct(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintStruct(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1350,51 +1334,14 @@ func (m *Struct) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var keykey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStruct
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				keykey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			var stringLenmapkey uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStruct
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLenmapkey |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLenmapkey := int(stringLenmapkey)
-			if intStringLenmapkey < 0 {
-				return ErrInvalidLengthStruct
-			}
-			postStringIndexmapkey := iNdEx + intStringLenmapkey
-			if postStringIndexmapkey > l {
-				return io.ErrUnexpectedEOF
-			}
-			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
-			iNdEx = postStringIndexmapkey
 			if m.Fields == nil {
 				m.Fields = make(map[string]*Value)
 			}
-			if iNdEx < postIndex {
-				var valuekey uint64
+			var mapkey string
+			var mapvalue *Value
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return ErrIntOverflowStruct
@@ -1404,46 +1351,85 @@ func (m *Struct) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					valuekey |= (uint64(b) & 0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				var mapmsglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowStruct
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowStruct
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
-					if iNdEx >= l {
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return ErrInvalidLengthStruct
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					mapmsglen |= (int(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowStruct
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= (int(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
 					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthStruct
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if mapmsglen < 0 {
+						return ErrInvalidLengthStruct
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &Value{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipStruct(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthStruct
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
-				if mapmsglen < 0 {
-					return ErrInvalidLengthStruct
-				}
-				postmsgIndex := iNdEx + mapmsglen
-				if mapmsglen < 0 {
-					return ErrInvalidLengthStruct
-				}
-				if postmsgIndex > l {
-					return io.ErrUnexpectedEOF
-				}
-				mapvalue := &Value{}
-				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-					return err
-				}
-				iNdEx = postmsgIndex
-				m.Fields[mapkey] = mapvalue
-			} else {
-				var mapvalue *Value
-				m.Fields[mapkey] = mapvalue
 			}
+			m.Fields[mapkey] = mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -1523,15 +1509,8 @@ func (m *Value) Unmarshal(dAtA []byte) error {
 			if (iNdEx + 8) > l {
 				return io.ErrUnexpectedEOF
 			}
+			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
 			iNdEx += 8
-			v = uint64(dAtA[iNdEx-8])
-			v |= uint64(dAtA[iNdEx-7]) << 8
-			v |= uint64(dAtA[iNdEx-6]) << 16
-			v |= uint64(dAtA[iNdEx-5]) << 24
-			v |= uint64(dAtA[iNdEx-4]) << 32
-			v |= uint64(dAtA[iNdEx-3]) << 40
-			v |= uint64(dAtA[iNdEx-2]) << 48
-			v |= uint64(dAtA[iNdEx-1]) << 56
 			m.Kind = &Value_NumberValue{float64(math.Float64frombits(v))}
 		case 3:
 			if wireType != 2 {
diff --git a/vendor/github.com/gogo/protobuf/types/timestamp.go b/vendor/github.com/gogo/protobuf/types/timestamp.go
index 521b62d925e..7ae54d8b3ff 100644
--- a/vendor/github.com/gogo/protobuf/types/timestamp.go
+++ b/vendor/github.com/gogo/protobuf/types/timestamp.go
@@ -97,6 +97,15 @@ func TimestampFromProto(ts *Timestamp) (time.Time, error) {
 	return t, validateTimestamp(ts)
 }
 
+// TimestampNow returns a google.protobuf.Timestamp for the current time.
+func TimestampNow() *Timestamp {
+	ts, err := TimestampProto(time.Now())
+	if err != nil {
+		panic("ptypes: time.Now() out of Timestamp range")
+	}
+	return ts
+}
+
 // TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
 // It returns an error if the resulting Timestamp is invalid.
 func TimestampProto(t time.Time) (*Timestamp, error) {
diff --git a/vendor/github.com/gogo/protobuf/types/timestamp.pb.go b/vendor/github.com/gogo/protobuf/types/timestamp.pb.go
index 8c705a3a304..265133fd671 100644
--- a/vendor/github.com/gogo/protobuf/types/timestamp.pb.go
+++ b/vendor/github.com/gogo/protobuf/types/timestamp.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: timestamp.proto
-// DO NOT EDIT!
 
 /*
 	Package types is a generated protocol buffer package.
@@ -45,6 +44,8 @@ const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
 // and from  RFC 3339 date strings.
 // See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
 //
+// # Examples
+//
 // Example 1: Compute Timestamp from POSIX `time()`.
 //
 //     Timestamp timestamp;
@@ -85,6 +86,29 @@ const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
 //     timestamp = Timestamp()
 //     timestamp.GetCurrentTime()
 //
+// # JSON Mapping
+//
+// In JSON format, the Timestamp type is encoded as a string in the
+// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+// where {year} is always expressed using four digits while {month}, {day},
+// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+// is required, though only UTC (as indicated by "Z") is presently supported.
+//
+// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+// 01:30 UTC on January 15, 2017.
+//
+// In JavaScript, one can convert a Date object to this format using the
+// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
+// method. In Python, a standard `datetime.datetime` object can be converted
+// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
+// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
+// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
+// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime())
+// to obtain a formatter capable of generating timestamps in this format.
+//
 //
 type Timestamp struct {
 	// Represents seconds of UTC time since Unix epoch
@@ -239,24 +263,6 @@ func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Timestamp(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Timestamp(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintTimestamp(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
diff --git a/vendor/github.com/gogo/protobuf/types/wrappers.pb.go b/vendor/github.com/gogo/protobuf/types/wrappers.pb.go
index 125e35c8f4c..60edd60d9e3 100644
--- a/vendor/github.com/gogo/protobuf/types/wrappers.pb.go
+++ b/vendor/github.com/gogo/protobuf/types/wrappers.pb.go
@@ -1,6 +1,5 @@
-// Code generated by protoc-gen-gogo.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: wrappers.proto
-// DO NOT EDIT!
 
 /*
 Package types is a generated protocol buffer package.
@@ -30,6 +29,8 @@ import bytes "bytes"
 import strings "strings"
 import reflect "reflect"
 
+import encoding_binary "encoding/binary"
+
 import io "io"
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -914,7 +915,8 @@ func (m *DoubleValue) MarshalTo(dAtA []byte) (int, error) {
 	if m.Value != 0 {
 		dAtA[i] = 0x9
 		i++
-		i = encodeFixed64Wrappers(dAtA, i, uint64(math.Float64bits(float64(m.Value))))
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
+		i += 8
 	}
 	return i, nil
 }
@@ -937,7 +939,8 @@ func (m *FloatValue) MarshalTo(dAtA []byte) (int, error) {
 	if m.Value != 0 {
 		dAtA[i] = 0xd
 		i++
-		i = encodeFixed32Wrappers(dAtA, i, uint32(math.Float32bits(float32(m.Value))))
+		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Value))))
+		i += 4
 	}
 	return i, nil
 }
@@ -1110,24 +1113,6 @@ func (m *BytesValue) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func encodeFixed64Wrappers(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Wrappers(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
 func encodeVarintWrappers(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1528,15 +1513,8 @@ func (m *DoubleValue) Unmarshal(dAtA []byte) error {
 			if (iNdEx + 8) > l {
 				return io.ErrUnexpectedEOF
 			}
+			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
 			iNdEx += 8
-			v = uint64(dAtA[iNdEx-8])
-			v |= uint64(dAtA[iNdEx-7]) << 8
-			v |= uint64(dAtA[iNdEx-6]) << 16
-			v |= uint64(dAtA[iNdEx-5]) << 24
-			v |= uint64(dAtA[iNdEx-4]) << 32
-			v |= uint64(dAtA[iNdEx-3]) << 40
-			v |= uint64(dAtA[iNdEx-2]) << 48
-			v |= uint64(dAtA[iNdEx-1]) << 56
 			m.Value = float64(math.Float64frombits(v))
 		default:
 			iNdEx = preIndex
@@ -1596,11 +1574,8 @@ func (m *FloatValue) Unmarshal(dAtA []byte) error {
 			if (iNdEx + 4) > l {
 				return io.ErrUnexpectedEOF
 			}
+			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
 			iNdEx += 4
-			v = uint32(dAtA[iNdEx-4])
-			v |= uint32(dAtA[iNdEx-3]) << 8
-			v |= uint32(dAtA[iNdEx-2]) << 16
-			v |= uint32(dAtA[iNdEx-1]) << 24
 			m.Value = float32(math.Float32frombits(v))
 		default:
 			iNdEx = preIndex
diff --git a/vendor/github.com/gogo/protobuf/vanity/field.go b/vendor/github.com/gogo/protobuf/vanity/field.go
index 9c5e2263c10..62cdddfabb4 100644
--- a/vendor/github.com/gogo/protobuf/vanity/field.go
+++ b/vendor/github.com/gogo/protobuf/vanity/field.go
@@ -72,6 +72,13 @@ func TurnOffNullable(field *descriptor.FieldDescriptorProto) {
 	SetBoolFieldOption(gogoproto.E_Nullable, false)(field)
 }
 
+func TurnOffNullableForNativeTypes(field *descriptor.FieldDescriptorProto) {
+	if field.IsRepeated() || field.IsMessage() {
+		return
+	}
+	SetBoolFieldOption(gogoproto.E_Nullable, false)(field)
+}
+
 func TurnOffNullableForNativeTypesWithoutDefaultsOnly(field *descriptor.FieldDescriptorProto) {
 	if field.IsRepeated() || field.IsMessage() {
 		return
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/BUILD b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/BUILD
deleted file mode 100644
index 0263d174a47..00000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/BUILD
+++ /dev/null
@@ -1,24 +0,0 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["descriptor.pb.go"],
-    importmap = "k8s.io/kubernetes/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor",
-    importpath = "github.com/golang/protobuf/protoc-gen-go/descriptor",
-    visibility = ["//visibility:public"],
-    deps = ["//vendor/github.com/golang/protobuf/proto:go_default_library"],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
deleted file mode 100644
index 9e029e8cb44..00000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
+++ /dev/null
@@ -1,2812 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/descriptor.proto
-
-package descriptor
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type FieldDescriptorProto_Type int32
-
-const (
-	// 0 is reserved for errors.
-	// Order is weird for historical reasons.
-	FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1
-	FieldDescriptorProto_TYPE_FLOAT  FieldDescriptorProto_Type = 2
-	// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
-	// negative values are likely.
-	FieldDescriptorProto_TYPE_INT64  FieldDescriptorProto_Type = 3
-	FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4
-	// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
-	// negative values are likely.
-	FieldDescriptorProto_TYPE_INT32   FieldDescriptorProto_Type = 5
-	FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6
-	FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7
-	FieldDescriptorProto_TYPE_BOOL    FieldDescriptorProto_Type = 8
-	FieldDescriptorProto_TYPE_STRING  FieldDescriptorProto_Type = 9
-	// Tag-delimited aggregate.
-	// Group type is deprecated and not supported in proto3. However, Proto3
-	// implementations should still be able to parse the group wire format and
-	// treat group fields as unknown fields.
-	FieldDescriptorProto_TYPE_GROUP   FieldDescriptorProto_Type = 10
-	FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11
-	// New in version 2.
-	FieldDescriptorProto_TYPE_BYTES    FieldDescriptorProto_Type = 12
-	FieldDescriptorProto_TYPE_UINT32   FieldDescriptorProto_Type = 13
-	FieldDescriptorProto_TYPE_ENUM     FieldDescriptorProto_Type = 14
-	FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15
-	FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16
-	FieldDescriptorProto_TYPE_SINT32   FieldDescriptorProto_Type = 17
-	FieldDescriptorProto_TYPE_SINT64   FieldDescriptorProto_Type = 18
-)
-
-var FieldDescriptorProto_Type_name = map[int32]string{
-	1:  "TYPE_DOUBLE",
-	2:  "TYPE_FLOAT",
-	3:  "TYPE_INT64",
-	4:  "TYPE_UINT64",
-	5:  "TYPE_INT32",
-	6:  "TYPE_FIXED64",
-	7:  "TYPE_FIXED32",
-	8:  "TYPE_BOOL",
-	9:  "TYPE_STRING",
-	10: "TYPE_GROUP",
-	11: "TYPE_MESSAGE",
-	12: "TYPE_BYTES",
-	13: "TYPE_UINT32",
-	14: "TYPE_ENUM",
-	15: "TYPE_SFIXED32",
-	16: "TYPE_SFIXED64",
-	17: "TYPE_SINT32",
-	18: "TYPE_SINT64",
-}
-var FieldDescriptorProto_Type_value = map[string]int32{
-	"TYPE_DOUBLE":   1,
-	"TYPE_FLOAT":    2,
-	"TYPE_INT64":    3,
-	"TYPE_UINT64":   4,
-	"TYPE_INT32":    5,
-	"TYPE_FIXED64":  6,
-	"TYPE_FIXED32":  7,
-	"TYPE_BOOL":     8,
-	"TYPE_STRING":   9,
-	"TYPE_GROUP":    10,
-	"TYPE_MESSAGE":  11,
-	"TYPE_BYTES":    12,
-	"TYPE_UINT32":   13,
-	"TYPE_ENUM":     14,
-	"TYPE_SFIXED32": 15,
-	"TYPE_SFIXED64": 16,
-	"TYPE_SINT32":   17,
-	"TYPE_SINT64":   18,
-}
-
-func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type {
-	p := new(FieldDescriptorProto_Type)
-	*p = x
-	return p
-}
-func (x FieldDescriptorProto_Type) String() string {
-	return proto.EnumName(FieldDescriptorProto_Type_name, int32(x))
-}
-func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type")
-	if err != nil {
-		return err
-	}
-	*x = FieldDescriptorProto_Type(value)
-	return nil
-}
-func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{4, 0}
-}
-
-type FieldDescriptorProto_Label int32
-
-const (
-	// 0 is reserved for errors
-	FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1
-	FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2
-	FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3
-)
-
-var FieldDescriptorProto_Label_name = map[int32]string{
-	1: "LABEL_OPTIONAL",
-	2: "LABEL_REQUIRED",
-	3: "LABEL_REPEATED",
-}
-var FieldDescriptorProto_Label_value = map[string]int32{
-	"LABEL_OPTIONAL": 1,
-	"LABEL_REQUIRED": 2,
-	"LABEL_REPEATED": 3,
-}
-
-func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label {
-	p := new(FieldDescriptorProto_Label)
-	*p = x
-	return p
-}
-func (x FieldDescriptorProto_Label) String() string {
-	return proto.EnumName(FieldDescriptorProto_Label_name, int32(x))
-}
-func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label")
-	if err != nil {
-		return err
-	}
-	*x = FieldDescriptorProto_Label(value)
-	return nil
-}
-func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{4, 1}
-}
-
-// Generated classes can be optimized for speed or code size.
-type FileOptions_OptimizeMode int32
-
-const (
-	FileOptions_SPEED FileOptions_OptimizeMode = 1
-	// etc.
-	FileOptions_CODE_SIZE    FileOptions_OptimizeMode = 2
-	FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3
-)
-
-var FileOptions_OptimizeMode_name = map[int32]string{
-	1: "SPEED",
-	2: "CODE_SIZE",
-	3: "LITE_RUNTIME",
-}
-var FileOptions_OptimizeMode_value = map[string]int32{
-	"SPEED":        1,
-	"CODE_SIZE":    2,
-	"LITE_RUNTIME": 3,
-}
-
-func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode {
-	p := new(FileOptions_OptimizeMode)
-	*p = x
-	return p
-}
-func (x FileOptions_OptimizeMode) String() string {
-	return proto.EnumName(FileOptions_OptimizeMode_name, int32(x))
-}
-func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode")
-	if err != nil {
-		return err
-	}
-	*x = FileOptions_OptimizeMode(value)
-	return nil
-}
-func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{10, 0}
-}
-
-type FieldOptions_CType int32
-
-const (
-	// Default mode.
-	FieldOptions_STRING       FieldOptions_CType = 0
-	FieldOptions_CORD         FieldOptions_CType = 1
-	FieldOptions_STRING_PIECE FieldOptions_CType = 2
-)
-
-var FieldOptions_CType_name = map[int32]string{
-	0: "STRING",
-	1: "CORD",
-	2: "STRING_PIECE",
-}
-var FieldOptions_CType_value = map[string]int32{
-	"STRING":       0,
-	"CORD":         1,
-	"STRING_PIECE": 2,
-}
-
-func (x FieldOptions_CType) Enum() *FieldOptions_CType {
-	p := new(FieldOptions_CType)
-	*p = x
-	return p
-}
-func (x FieldOptions_CType) String() string {
-	return proto.EnumName(FieldOptions_CType_name, int32(x))
-}
-func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType")
-	if err != nil {
-		return err
-	}
-	*x = FieldOptions_CType(value)
-	return nil
-}
-func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{12, 0}
-}
-
-type FieldOptions_JSType int32
-
-const (
-	// Use the default type.
-	FieldOptions_JS_NORMAL FieldOptions_JSType = 0
-	// Use JavaScript strings.
-	FieldOptions_JS_STRING FieldOptions_JSType = 1
-	// Use JavaScript numbers.
-	FieldOptions_JS_NUMBER FieldOptions_JSType = 2
-)
-
-var FieldOptions_JSType_name = map[int32]string{
-	0: "JS_NORMAL",
-	1: "JS_STRING",
-	2: "JS_NUMBER",
-}
-var FieldOptions_JSType_value = map[string]int32{
-	"JS_NORMAL": 0,
-	"JS_STRING": 1,
-	"JS_NUMBER": 2,
-}
-
-func (x FieldOptions_JSType) Enum() *FieldOptions_JSType {
-	p := new(FieldOptions_JSType)
-	*p = x
-	return p
-}
-func (x FieldOptions_JSType) String() string {
-	return proto.EnumName(FieldOptions_JSType_name, int32(x))
-}
-func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FieldOptions_JSType_value, data, "FieldOptions_JSType")
-	if err != nil {
-		return err
-	}
-	*x = FieldOptions_JSType(value)
-	return nil
-}
-func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{12, 1}
-}
-
-// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
-// or neither? HTTP based RPC implementation may choose GET verb for safe
-// methods, and PUT verb for idempotent methods instead of the default POST.
-type MethodOptions_IdempotencyLevel int32
-
-const (
-	MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0
-	MethodOptions_NO_SIDE_EFFECTS     MethodOptions_IdempotencyLevel = 1
-	MethodOptions_IDEMPOTENT          MethodOptions_IdempotencyLevel = 2
-)
-
-var MethodOptions_IdempotencyLevel_name = map[int32]string{
-	0: "IDEMPOTENCY_UNKNOWN",
-	1: "NO_SIDE_EFFECTS",
-	2: "IDEMPOTENT",
-}
-var MethodOptions_IdempotencyLevel_value = map[string]int32{
-	"IDEMPOTENCY_UNKNOWN": 0,
-	"NO_SIDE_EFFECTS":     1,
-	"IDEMPOTENT":          2,
-}
-
-func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel {
-	p := new(MethodOptions_IdempotencyLevel)
-	*p = x
-	return p
-}
-func (x MethodOptions_IdempotencyLevel) String() string {
-	return proto.EnumName(MethodOptions_IdempotencyLevel_name, int32(x))
-}
-func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(MethodOptions_IdempotencyLevel_value, data, "MethodOptions_IdempotencyLevel")
-	if err != nil {
-		return err
-	}
-	*x = MethodOptions_IdempotencyLevel(value)
-	return nil
-}
-func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{17, 0}
-}
-
-// The protocol compiler can output a FileDescriptorSet containing the .proto
-// files it parses.
-type FileDescriptorSet struct {
-	File                 []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
-	XXX_unrecognized     []byte                 `json:"-"`
-	XXX_sizecache        int32                  `json:"-"`
-}
-
-func (m *FileDescriptorSet) Reset()         { *m = FileDescriptorSet{} }
-func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) }
-func (*FileDescriptorSet) ProtoMessage()    {}
-func (*FileDescriptorSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{0}
-}
-func (m *FileDescriptorSet) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FileDescriptorSet.Unmarshal(m, b)
-}
-func (m *FileDescriptorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FileDescriptorSet.Marshal(b, m, deterministic)
-}
-func (dst *FileDescriptorSet) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FileDescriptorSet.Merge(dst, src)
-}
-func (m *FileDescriptorSet) XXX_Size() int {
-	return xxx_messageInfo_FileDescriptorSet.Size(m)
-}
-func (m *FileDescriptorSet) XXX_DiscardUnknown() {
-	xxx_messageInfo_FileDescriptorSet.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FileDescriptorSet proto.InternalMessageInfo
-
-func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto {
-	if m != nil {
-		return m.File
-	}
-	return nil
-}
-
-// Describes a complete .proto file.
-type FileDescriptorProto struct {
-	Name    *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"`
-	// Names of files imported by this file.
-	Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"`
-	// Indexes of the public imported files in the dependency list above.
-	PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"`
-	// Indexes of the weak imported files in the dependency list.
-	// For Google-internal migration only. Do not use.
-	WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
-	// All top-level definitions in this file.
-	MessageType []*DescriptorProto        `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
-	EnumType    []*EnumDescriptorProto    `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
-	Service     []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"`
-	Extension   []*FieldDescriptorProto   `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"`
-	Options     *FileOptions              `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
-	// This field contains optional information about the original source code.
-	// You may safely remove this entire field without harming runtime
-	// functionality of the descriptors -- the information is needed only by
-	// development tools.
-	SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"`
-	// The syntax of the proto file.
-	// The supported values are "proto2" and "proto3".
-	Syntax               *string  `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *FileDescriptorProto) Reset()         { *m = FileDescriptorProto{} }
-func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*FileDescriptorProto) ProtoMessage()    {}
-func (*FileDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{1}
-}
-func (m *FileDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FileDescriptorProto.Unmarshal(m, b)
-}
-func (m *FileDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FileDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *FileDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FileDescriptorProto.Merge(dst, src)
-}
-func (m *FileDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_FileDescriptorProto.Size(m)
-}
-func (m *FileDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_FileDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FileDescriptorProto proto.InternalMessageInfo
-
-func (m *FileDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *FileDescriptorProto) GetPackage() string {
-	if m != nil && m.Package != nil {
-		return *m.Package
-	}
-	return ""
-}
-
-func (m *FileDescriptorProto) GetDependency() []string {
-	if m != nil {
-		return m.Dependency
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetPublicDependency() []int32 {
-	if m != nil {
-		return m.PublicDependency
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetWeakDependency() []int32 {
-	if m != nil {
-		return m.WeakDependency
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto {
-	if m != nil {
-		return m.MessageType
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto {
-	if m != nil {
-		return m.EnumType
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto {
-	if m != nil {
-		return m.Service
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto {
-	if m != nil {
-		return m.Extension
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetOptions() *FileOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo {
-	if m != nil {
-		return m.SourceCodeInfo
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetSyntax() string {
-	if m != nil && m.Syntax != nil {
-		return *m.Syntax
-	}
-	return ""
-}
-
-// Describes a message type.
-type DescriptorProto struct {
-	Name           *string                           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Field          []*FieldDescriptorProto           `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
-	Extension      []*FieldDescriptorProto           `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"`
-	NestedType     []*DescriptorProto                `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"`
-	EnumType       []*EnumDescriptorProto            `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
-	ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"`
-	OneofDecl      []*OneofDescriptorProto           `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"`
-	Options        *MessageOptions                   `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"`
-	ReservedRange  []*DescriptorProto_ReservedRange  `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
-	// Reserved field names, which may not be used by fields in the same message.
-	// A given name may only be reserved once.
-	ReservedName         []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *DescriptorProto) Reset()         { *m = DescriptorProto{} }
-func (m *DescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*DescriptorProto) ProtoMessage()    {}
-func (*DescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{2}
-}
-func (m *DescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DescriptorProto.Unmarshal(m, b)
-}
-func (m *DescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *DescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DescriptorProto.Merge(dst, src)
-}
-func (m *DescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_DescriptorProto.Size(m)
-}
-func (m *DescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_DescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DescriptorProto proto.InternalMessageInfo
-
-func (m *DescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *DescriptorProto) GetField() []*FieldDescriptorProto {
-	if m != nil {
-		return m.Field
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto {
-	if m != nil {
-		return m.Extension
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetNestedType() []*DescriptorProto {
-	if m != nil {
-		return m.NestedType
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto {
-	if m != nil {
-		return m.EnumType
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange {
-	if m != nil {
-		return m.ExtensionRange
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto {
-	if m != nil {
-		return m.OneofDecl
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetOptions() *MessageOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange {
-	if m != nil {
-		return m.ReservedRange
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetReservedName() []string {
-	if m != nil {
-		return m.ReservedName
-	}
-	return nil
-}
-
-type DescriptorProto_ExtensionRange struct {
-	Start                *int32                 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
-	End                  *int32                 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
-	Options              *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
-	XXX_unrecognized     []byte                 `json:"-"`
-	XXX_sizecache        int32                  `json:"-"`
-}
-
-func (m *DescriptorProto_ExtensionRange) Reset()         { *m = DescriptorProto_ExtensionRange{} }
-func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) }
-func (*DescriptorProto_ExtensionRange) ProtoMessage()    {}
-func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{2, 0}
-}
-func (m *DescriptorProto_ExtensionRange) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DescriptorProto_ExtensionRange.Unmarshal(m, b)
-}
-func (m *DescriptorProto_ExtensionRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DescriptorProto_ExtensionRange.Marshal(b, m, deterministic)
-}
-func (dst *DescriptorProto_ExtensionRange) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DescriptorProto_ExtensionRange.Merge(dst, src)
-}
-func (m *DescriptorProto_ExtensionRange) XXX_Size() int {
-	return xxx_messageInfo_DescriptorProto_ExtensionRange.Size(m)
-}
-func (m *DescriptorProto_ExtensionRange) XXX_DiscardUnknown() {
-	xxx_messageInfo_DescriptorProto_ExtensionRange.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DescriptorProto_ExtensionRange proto.InternalMessageInfo
-
-func (m *DescriptorProto_ExtensionRange) GetStart() int32 {
-	if m != nil && m.Start != nil {
-		return *m.Start
-	}
-	return 0
-}
-
-func (m *DescriptorProto_ExtensionRange) GetEnd() int32 {
-	if m != nil && m.End != nil {
-		return *m.End
-	}
-	return 0
-}
-
-func (m *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-// Range of reserved tag numbers. Reserved tag numbers may not be used by
-// fields or extension ranges in the same message. Reserved ranges may
-// not overlap.
-type DescriptorProto_ReservedRange struct {
-	Start                *int32   `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
-	End                  *int32   `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *DescriptorProto_ReservedRange) Reset()         { *m = DescriptorProto_ReservedRange{} }
-func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) }
-func (*DescriptorProto_ReservedRange) ProtoMessage()    {}
-func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{2, 1}
-}
-func (m *DescriptorProto_ReservedRange) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DescriptorProto_ReservedRange.Unmarshal(m, b)
-}
-func (m *DescriptorProto_ReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DescriptorProto_ReservedRange.Marshal(b, m, deterministic)
-}
-func (dst *DescriptorProto_ReservedRange) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DescriptorProto_ReservedRange.Merge(dst, src)
-}
-func (m *DescriptorProto_ReservedRange) XXX_Size() int {
-	return xxx_messageInfo_DescriptorProto_ReservedRange.Size(m)
-}
-func (m *DescriptorProto_ReservedRange) XXX_DiscardUnknown() {
-	xxx_messageInfo_DescriptorProto_ReservedRange.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DescriptorProto_ReservedRange proto.InternalMessageInfo
-
-func (m *DescriptorProto_ReservedRange) GetStart() int32 {
-	if m != nil && m.Start != nil {
-		return *m.Start
-	}
-	return 0
-}
-
-func (m *DescriptorProto_ReservedRange) GetEnd() int32 {
-	if m != nil && m.End != nil {
-		return *m.End
-	}
-	return 0
-}
-
-type ExtensionRangeOptions struct {
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *ExtensionRangeOptions) Reset()         { *m = ExtensionRangeOptions{} }
-func (m *ExtensionRangeOptions) String() string { return proto.CompactTextString(m) }
-func (*ExtensionRangeOptions) ProtoMessage()    {}
-func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{3}
-}
-
-var extRange_ExtensionRangeOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*ExtensionRangeOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_ExtensionRangeOptions
-}
-func (m *ExtensionRangeOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ExtensionRangeOptions.Unmarshal(m, b)
-}
-func (m *ExtensionRangeOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ExtensionRangeOptions.Marshal(b, m, deterministic)
-}
-func (dst *ExtensionRangeOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ExtensionRangeOptions.Merge(dst, src)
-}
-func (m *ExtensionRangeOptions) XXX_Size() int {
-	return xxx_messageInfo_ExtensionRangeOptions.Size(m)
-}
-func (m *ExtensionRangeOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_ExtensionRangeOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ExtensionRangeOptions proto.InternalMessageInfo
-
-func (m *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-// Describes a field within a message.
-type FieldDescriptorProto struct {
-	Name   *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Number *int32                      `protobuf:"varint,3,opt,name=number" json:"number,omitempty"`
-	Label  *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"`
-	// If type_name is set, this need not be set.  If both this and type_name
-	// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
-	Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"`
-	// For message and enum types, this is the name of the type.  If the name
-	// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
-	// rules are used to find the type (i.e. first the nested types within this
-	// message are searched, then within the parent, on up to the root
-	// namespace).
-	TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
-	// For extensions, this is the name of the type being extended.  It is
-	// resolved in the same manner as type_name.
-	Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"`
-	// For numeric types, contains the original text representation of the value.
-	// For booleans, "true" or "false".
-	// For strings, contains the default text contents (not escaped in any way).
-	// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
-	// TODO(kenton):  Base-64 encode?
-	DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"`
-	// If set, gives the index of a oneof in the containing type's oneof_decl
-	// list.  This field is a member of that oneof.
-	OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"`
-	// JSON name of this field. The value is set by protocol compiler. If the
-	// user has set a "json_name" option on this field, that option's value
-	// will be used. Otherwise, it's deduced from the field's name by converting
-	// it to camelCase.
-	JsonName             *string       `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"`
-	Options              *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
-}
-
-func (m *FieldDescriptorProto) Reset()         { *m = FieldDescriptorProto{} }
-func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*FieldDescriptorProto) ProtoMessage()    {}
-func (*FieldDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{4}
-}
-func (m *FieldDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FieldDescriptorProto.Unmarshal(m, b)
-}
-func (m *FieldDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FieldDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *FieldDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FieldDescriptorProto.Merge(dst, src)
-}
-func (m *FieldDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_FieldDescriptorProto.Size(m)
-}
-func (m *FieldDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_FieldDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FieldDescriptorProto proto.InternalMessageInfo
-
-func (m *FieldDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *FieldDescriptorProto) GetNumber() int32 {
-	if m != nil && m.Number != nil {
-		return *m.Number
-	}
-	return 0
-}
-
-func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label {
-	if m != nil && m.Label != nil {
-		return *m.Label
-	}
-	return FieldDescriptorProto_LABEL_OPTIONAL
-}
-
-func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type {
-	if m != nil && m.Type != nil {
-		return *m.Type
-	}
-	return FieldDescriptorProto_TYPE_DOUBLE
-}
-
-func (m *FieldDescriptorProto) GetTypeName() string {
-	if m != nil && m.TypeName != nil {
-		return *m.TypeName
-	}
-	return ""
-}
-
-func (m *FieldDescriptorProto) GetExtendee() string {
-	if m != nil && m.Extendee != nil {
-		return *m.Extendee
-	}
-	return ""
-}
-
-func (m *FieldDescriptorProto) GetDefaultValue() string {
-	if m != nil && m.DefaultValue != nil {
-		return *m.DefaultValue
-	}
-	return ""
-}
-
-func (m *FieldDescriptorProto) GetOneofIndex() int32 {
-	if m != nil && m.OneofIndex != nil {
-		return *m.OneofIndex
-	}
-	return 0
-}
-
-func (m *FieldDescriptorProto) GetJsonName() string {
-	if m != nil && m.JsonName != nil {
-		return *m.JsonName
-	}
-	return ""
-}
-
-func (m *FieldDescriptorProto) GetOptions() *FieldOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-// Describes a oneof.
-type OneofDescriptorProto struct {
-	Name                 *string       `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Options              *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
-}
-
-func (m *OneofDescriptorProto) Reset()         { *m = OneofDescriptorProto{} }
-func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*OneofDescriptorProto) ProtoMessage()    {}
-func (*OneofDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{5}
-}
-func (m *OneofDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_OneofDescriptorProto.Unmarshal(m, b)
-}
-func (m *OneofDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_OneofDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *OneofDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OneofDescriptorProto.Merge(dst, src)
-}
-func (m *OneofDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_OneofDescriptorProto.Size(m)
-}
-func (m *OneofDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_OneofDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_OneofDescriptorProto proto.InternalMessageInfo
-
-func (m *OneofDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *OneofDescriptorProto) GetOptions() *OneofOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-// Describes an enum type.
-type EnumDescriptorProto struct {
-	Name    *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Value   []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
-	Options *EnumOptions                `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-	// Range of reserved numeric values. Reserved numeric values may not be used
-	// by enum values in the same enum declaration. Reserved ranges may not
-	// overlap.
-	ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
-	// Reserved enum value names, which may not be reused. A given name may only
-	// be reserved once.
-	ReservedName         []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EnumDescriptorProto) Reset()         { *m = EnumDescriptorProto{} }
-func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*EnumDescriptorProto) ProtoMessage()    {}
-func (*EnumDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{6}
-}
-func (m *EnumDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EnumDescriptorProto.Unmarshal(m, b)
-}
-func (m *EnumDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EnumDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *EnumDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EnumDescriptorProto.Merge(dst, src)
-}
-func (m *EnumDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_EnumDescriptorProto.Size(m)
-}
-func (m *EnumDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_EnumDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EnumDescriptorProto proto.InternalMessageInfo
-
-func (m *EnumDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-func (m *EnumDescriptorProto) GetOptions() *EnumOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-func (m *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange {
-	if m != nil {
-		return m.ReservedRange
-	}
-	return nil
-}
-
-func (m *EnumDescriptorProto) GetReservedName() []string {
-	if m != nil {
-		return m.ReservedName
-	}
-	return nil
-}
-
-// Range of reserved numeric values. Reserved values may not be used by
-// entries in the same enum. Reserved ranges may not overlap.
-//
-// Note that this is distinct from DescriptorProto.ReservedRange in that it
-// is inclusive such that it can appropriately represent the entire int32
-// domain.
-type EnumDescriptorProto_EnumReservedRange struct {
-	Start                *int32   `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
-	End                  *int32   `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EnumDescriptorProto_EnumReservedRange) Reset()         { *m = EnumDescriptorProto_EnumReservedRange{} }
-func (m *EnumDescriptorProto_EnumReservedRange) String() string { return proto.CompactTextString(m) }
-func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage()    {}
-func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{6, 0}
-}
-func (m *EnumDescriptorProto_EnumReservedRange) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Unmarshal(m, b)
-}
-func (m *EnumDescriptorProto_EnumReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Marshal(b, m, deterministic)
-}
-func (dst *EnumDescriptorProto_EnumReservedRange) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Merge(dst, src)
-}
-func (m *EnumDescriptorProto_EnumReservedRange) XXX_Size() int {
-	return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Size(m)
-}
-func (m *EnumDescriptorProto_EnumReservedRange) XXX_DiscardUnknown() {
-	xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EnumDescriptorProto_EnumReservedRange proto.InternalMessageInfo
-
-func (m *EnumDescriptorProto_EnumReservedRange) GetStart() int32 {
-	if m != nil && m.Start != nil {
-		return *m.Start
-	}
-	return 0
-}
-
-func (m *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 {
-	if m != nil && m.End != nil {
-		return *m.End
-	}
-	return 0
-}
-
-// Describes a value within an enum.
-type EnumValueDescriptorProto struct {
-	Name                 *string           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Number               *int32            `protobuf:"varint,2,opt,name=number" json:"number,omitempty"`
-	Options              *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
-}
-
-func (m *EnumValueDescriptorProto) Reset()         { *m = EnumValueDescriptorProto{} }
-func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*EnumValueDescriptorProto) ProtoMessage()    {}
-func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{7}
-}
-func (m *EnumValueDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EnumValueDescriptorProto.Unmarshal(m, b)
-}
-func (m *EnumValueDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EnumValueDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *EnumValueDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EnumValueDescriptorProto.Merge(dst, src)
-}
-func (m *EnumValueDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_EnumValueDescriptorProto.Size(m)
-}
-func (m *EnumValueDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_EnumValueDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EnumValueDescriptorProto proto.InternalMessageInfo
-
-func (m *EnumValueDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *EnumValueDescriptorProto) GetNumber() int32 {
-	if m != nil && m.Number != nil {
-		return *m.Number
-	}
-	return 0
-}
-
-func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-// Describes a service.
-type ServiceDescriptorProto struct {
-	Name                 *string                  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Method               []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"`
-	Options              *ServiceOptions          `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
-	XXX_unrecognized     []byte                   `json:"-"`
-	XXX_sizecache        int32                    `json:"-"`
-}
-
-func (m *ServiceDescriptorProto) Reset()         { *m = ServiceDescriptorProto{} }
-func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*ServiceDescriptorProto) ProtoMessage()    {}
-func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{8}
-}
-func (m *ServiceDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ServiceDescriptorProto.Unmarshal(m, b)
-}
-func (m *ServiceDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ServiceDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *ServiceDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ServiceDescriptorProto.Merge(dst, src)
-}
-func (m *ServiceDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_ServiceDescriptorProto.Size(m)
-}
-func (m *ServiceDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_ServiceDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ServiceDescriptorProto proto.InternalMessageInfo
-
-func (m *ServiceDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto {
-	if m != nil {
-		return m.Method
-	}
-	return nil
-}
-
-func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-// Describes a method of a service.
-type MethodDescriptorProto struct {
-	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	// Input and output type names.  These are resolved in the same way as
-	// FieldDescriptorProto.type_name, but must refer to a message type.
-	InputType  *string        `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"`
-	OutputType *string        `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"`
-	Options    *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"`
-	// Identifies if client streams multiple client messages
-	ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"`
-	// Identifies if server streams multiple server messages
-	ServerStreaming      *bool    `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *MethodDescriptorProto) Reset()         { *m = MethodDescriptorProto{} }
-func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*MethodDescriptorProto) ProtoMessage()    {}
-func (*MethodDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{9}
-}
-func (m *MethodDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_MethodDescriptorProto.Unmarshal(m, b)
-}
-func (m *MethodDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_MethodDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *MethodDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MethodDescriptorProto.Merge(dst, src)
-}
-func (m *MethodDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_MethodDescriptorProto.Size(m)
-}
-func (m *MethodDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_MethodDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MethodDescriptorProto proto.InternalMessageInfo
-
-const Default_MethodDescriptorProto_ClientStreaming bool = false
-const Default_MethodDescriptorProto_ServerStreaming bool = false
-
-func (m *MethodDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *MethodDescriptorProto) GetInputType() string {
-	if m != nil && m.InputType != nil {
-		return *m.InputType
-	}
-	return ""
-}
-
-func (m *MethodDescriptorProto) GetOutputType() string {
-	if m != nil && m.OutputType != nil {
-		return *m.OutputType
-	}
-	return ""
-}
-
-func (m *MethodDescriptorProto) GetOptions() *MethodOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-func (m *MethodDescriptorProto) GetClientStreaming() bool {
-	if m != nil && m.ClientStreaming != nil {
-		return *m.ClientStreaming
-	}
-	return Default_MethodDescriptorProto_ClientStreaming
-}
-
-func (m *MethodDescriptorProto) GetServerStreaming() bool {
-	if m != nil && m.ServerStreaming != nil {
-		return *m.ServerStreaming
-	}
-	return Default_MethodDescriptorProto_ServerStreaming
-}
-
-type FileOptions struct {
-	// Sets the Java package where classes generated from this .proto will be
-	// placed.  By default, the proto package is used, but this is often
-	// inappropriate because proto packages do not normally start with backwards
-	// domain names.
-	JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"`
-	// If set, all the classes from the .proto file are wrapped in a single
-	// outer class with the given name.  This applies to both Proto1
-	// (equivalent to the old "--one_java_file" option) and Proto2 (where
-	// a .proto always translates to a single class, but you may want to
-	// explicitly choose the class name).
-	JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"`
-	// If set true, then the Java code generator will generate a separate .java
-	// file for each top-level message, enum, and service defined in the .proto
-	// file.  Thus, these types will *not* be nested inside the outer class
-	// named by java_outer_classname.  However, the outer class will still be
-	// generated to contain the file's getDescriptor() method as well as any
-	// top-level extensions defined in the file.
-	JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"`
-	// This option does nothing.
-	JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"` // Deprecated: Do not use.
-	// If set true, then the Java2 code generator will generate code that
-	// throws an exception whenever an attempt is made to assign a non-UTF-8
-	// byte sequence to a string field.
-	// Message reflection will do the same.
-	// However, an extension field still accepts non-UTF-8 byte sequences.
-	// This option has no effect on when used with the lite runtime.
-	JavaStringCheckUtf8 *bool                     `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"`
-	OptimizeFor         *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"`
-	// Sets the Go package where structs generated from this .proto will be
-	// placed. If omitted, the Go package will be derived from the following:
-	//   - The basename of the package import path, if provided.
-	//   - Otherwise, the package statement in the .proto file, if present.
-	//   - Otherwise, the basename of the .proto file, without extension.
-	GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"`
-	// Should generic services be generated in each language?  "Generic" services
-	// are not specific to any particular RPC system.  They are generated by the
-	// main code generators in each language (without additional plugins).
-	// Generic services were the only kind of service generation supported by
-	// early versions of google.protobuf.
-	//
-	// Generic services are now considered deprecated in favor of using plugins
-	// that generate code specific to your particular RPC system.  Therefore,
-	// these default to false.  Old code which depends on generic services should
-	// explicitly set them to true.
-	CcGenericServices   *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
-	JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
-	PyGenericServices   *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
-	PhpGenericServices  *bool `protobuf:"varint,42,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"`
-	// Is this file deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for everything in the file, or it will be completely ignored; in the very
-	// least, this is a formalization for deprecating files.
-	Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// Enables the use of arenas for the proto messages in this file. This applies
-	// only to generated classes for C++.
-	CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=0" json:"cc_enable_arenas,omitempty"`
-	// Sets the objective c class prefix which is prepended to all objective c
-	// generated classes from this .proto. There is no default.
-	ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"`
-	// Namespace for generated classes; defaults to the package.
-	CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"`
-	// By default Swift generators will take the proto package and CamelCase it
-	// replacing '.' with underscore and use that to prefix the types/symbols
-	// defined. When this options is provided, they will use this value instead
-	// to prefix the types/symbols defined.
-	SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
-	// Sets the php class prefix which is prepended to all php generated classes
-	// from this .proto. Default is empty.
-	PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
-	// Use this option to change the namespace of php generated classes. Default
-	// is empty. When this option is empty, the package name will be used for
-	// determining the namespace.
-	PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
-	// The parser stores options it doesn't recognize here.
-	// See the documentation for the "Options" section above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *FileOptions) Reset()         { *m = FileOptions{} }
-func (m *FileOptions) String() string { return proto.CompactTextString(m) }
-func (*FileOptions) ProtoMessage()    {}
-func (*FileOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{10}
-}
-
-var extRange_FileOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_FileOptions
-}
-func (m *FileOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FileOptions.Unmarshal(m, b)
-}
-func (m *FileOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FileOptions.Marshal(b, m, deterministic)
-}
-func (dst *FileOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FileOptions.Merge(dst, src)
-}
-func (m *FileOptions) XXX_Size() int {
-	return xxx_messageInfo_FileOptions.Size(m)
-}
-func (m *FileOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_FileOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FileOptions proto.InternalMessageInfo
-
-const Default_FileOptions_JavaMultipleFiles bool = false
-const Default_FileOptions_JavaStringCheckUtf8 bool = false
-const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED
-const Default_FileOptions_CcGenericServices bool = false
-const Default_FileOptions_JavaGenericServices bool = false
-const Default_FileOptions_PyGenericServices bool = false
-const Default_FileOptions_PhpGenericServices bool = false
-const Default_FileOptions_Deprecated bool = false
-const Default_FileOptions_CcEnableArenas bool = false
-
-func (m *FileOptions) GetJavaPackage() string {
-	if m != nil && m.JavaPackage != nil {
-		return *m.JavaPackage
-	}
-	return ""
-}
-
-func (m *FileOptions) GetJavaOuterClassname() string {
-	if m != nil && m.JavaOuterClassname != nil {
-		return *m.JavaOuterClassname
-	}
-	return ""
-}
-
-func (m *FileOptions) GetJavaMultipleFiles() bool {
-	if m != nil && m.JavaMultipleFiles != nil {
-		return *m.JavaMultipleFiles
-	}
-	return Default_FileOptions_JavaMultipleFiles
-}
-
-// Deprecated: Do not use.
-func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool {
-	if m != nil && m.JavaGenerateEqualsAndHash != nil {
-		return *m.JavaGenerateEqualsAndHash
-	}
-	return false
-}
-
-func (m *FileOptions) GetJavaStringCheckUtf8() bool {
-	if m != nil && m.JavaStringCheckUtf8 != nil {
-		return *m.JavaStringCheckUtf8
-	}
-	return Default_FileOptions_JavaStringCheckUtf8
-}
-
-func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode {
-	if m != nil && m.OptimizeFor != nil {
-		return *m.OptimizeFor
-	}
-	return Default_FileOptions_OptimizeFor
-}
-
-func (m *FileOptions) GetGoPackage() string {
-	if m != nil && m.GoPackage != nil {
-		return *m.GoPackage
-	}
-	return ""
-}
-
-func (m *FileOptions) GetCcGenericServices() bool {
-	if m != nil && m.CcGenericServices != nil {
-		return *m.CcGenericServices
-	}
-	return Default_FileOptions_CcGenericServices
-}
-
-func (m *FileOptions) GetJavaGenericServices() bool {
-	if m != nil && m.JavaGenericServices != nil {
-		return *m.JavaGenericServices
-	}
-	return Default_FileOptions_JavaGenericServices
-}
-
-func (m *FileOptions) GetPyGenericServices() bool {
-	if m != nil && m.PyGenericServices != nil {
-		return *m.PyGenericServices
-	}
-	return Default_FileOptions_PyGenericServices
-}
-
-func (m *FileOptions) GetPhpGenericServices() bool {
-	if m != nil && m.PhpGenericServices != nil {
-		return *m.PhpGenericServices
-	}
-	return Default_FileOptions_PhpGenericServices
-}
-
-func (m *FileOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_FileOptions_Deprecated
-}
-
-func (m *FileOptions) GetCcEnableArenas() bool {
-	if m != nil && m.CcEnableArenas != nil {
-		return *m.CcEnableArenas
-	}
-	return Default_FileOptions_CcEnableArenas
-}
-
-func (m *FileOptions) GetObjcClassPrefix() string {
-	if m != nil && m.ObjcClassPrefix != nil {
-		return *m.ObjcClassPrefix
-	}
-	return ""
-}
-
-func (m *FileOptions) GetCsharpNamespace() string {
-	if m != nil && m.CsharpNamespace != nil {
-		return *m.CsharpNamespace
-	}
-	return ""
-}
-
-func (m *FileOptions) GetSwiftPrefix() string {
-	if m != nil && m.SwiftPrefix != nil {
-		return *m.SwiftPrefix
-	}
-	return ""
-}
-
-func (m *FileOptions) GetPhpClassPrefix() string {
-	if m != nil && m.PhpClassPrefix != nil {
-		return *m.PhpClassPrefix
-	}
-	return ""
-}
-
-func (m *FileOptions) GetPhpNamespace() string {
-	if m != nil && m.PhpNamespace != nil {
-		return *m.PhpNamespace
-	}
-	return ""
-}
-
-func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type MessageOptions struct {
-	// Set true to use the old proto1 MessageSet wire format for extensions.
-	// This is provided for backwards-compatibility with the MessageSet wire
-	// format.  You should not use this for any other reason:  It's less
-	// efficient, has fewer features, and is more complicated.
-	//
-	// The message must be defined exactly as follows:
-	//   message Foo {
-	//     option message_set_wire_format = true;
-	//     extensions 4 to max;
-	//   }
-	// Note that the message cannot have any defined fields; MessageSets only
-	// have extensions.
-	//
-	// All extensions of your type must be singular messages; e.g. they cannot
-	// be int32s, enums, or repeated messages.
-	//
-	// Because this is an option, the above two restrictions are not enforced by
-	// the protocol compiler.
-	MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"`
-	// Disables the generation of the standard "descriptor()" accessor, which can
-	// conflict with a field of the same name.  This is meant to make migration
-	// from proto1 easier; new code should avoid fields named "descriptor".
-	NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"`
-	// Is this message deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the message, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating messages.
-	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// Whether the message is an automatically generated map entry type for the
-	// maps field.
-	//
-	// For maps fields:
-	//     map<KeyType, ValueType> map_field = 1;
-	// The parsed descriptor looks like:
-	//     message MapFieldEntry {
-	//         option map_entry = true;
-	//         optional KeyType key = 1;
-	//         optional ValueType value = 2;
-	//     }
-	//     repeated MapFieldEntry map_field = 1;
-	//
-	// Implementations may choose not to generate the map_entry=true message, but
-	// use a native map in the target language to hold the keys and values.
-	// The reflection APIs in such implementions still need to work as
-	// if the field is a repeated message field.
-	//
-	// NOTE: Do not set the option in .proto files. Always use the maps syntax
-	// instead. The option should only be implicitly set by the proto compiler
-	// parser.
-	MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *MessageOptions) Reset()         { *m = MessageOptions{} }
-func (m *MessageOptions) String() string { return proto.CompactTextString(m) }
-func (*MessageOptions) ProtoMessage()    {}
-func (*MessageOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{11}
-}
-
-var extRange_MessageOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_MessageOptions
-}
-func (m *MessageOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_MessageOptions.Unmarshal(m, b)
-}
-func (m *MessageOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_MessageOptions.Marshal(b, m, deterministic)
-}
-func (dst *MessageOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MessageOptions.Merge(dst, src)
-}
-func (m *MessageOptions) XXX_Size() int {
-	return xxx_messageInfo_MessageOptions.Size(m)
-}
-func (m *MessageOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_MessageOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MessageOptions proto.InternalMessageInfo
-
-const Default_MessageOptions_MessageSetWireFormat bool = false
-const Default_MessageOptions_NoStandardDescriptorAccessor bool = false
-const Default_MessageOptions_Deprecated bool = false
-
-func (m *MessageOptions) GetMessageSetWireFormat() bool {
-	if m != nil && m.MessageSetWireFormat != nil {
-		return *m.MessageSetWireFormat
-	}
-	return Default_MessageOptions_MessageSetWireFormat
-}
-
-func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool {
-	if m != nil && m.NoStandardDescriptorAccessor != nil {
-		return *m.NoStandardDescriptorAccessor
-	}
-	return Default_MessageOptions_NoStandardDescriptorAccessor
-}
-
-func (m *MessageOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_MessageOptions_Deprecated
-}
-
-func (m *MessageOptions) GetMapEntry() bool {
-	if m != nil && m.MapEntry != nil {
-		return *m.MapEntry
-	}
-	return false
-}
-
-func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type FieldOptions struct {
-	// The ctype option instructs the C++ code generator to use a different
-	// representation of the field than it normally would.  See the specific
-	// options below.  This option is not yet implemented in the open source
-	// release -- sorry, we'll try to include it in a future version!
-	Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"`
-	// The packed option can be enabled for repeated primitive fields to enable
-	// a more efficient representation on the wire. Rather than repeatedly
-	// writing the tag and type for each element, the entire array is encoded as
-	// a single length-delimited blob. In proto3, only explicit setting it to
-	// false will avoid using packed encoding.
-	Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
-	// The jstype option determines the JavaScript type used for values of the
-	// field.  The option is permitted only for 64 bit integral and fixed types
-	// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
-	// is represented as JavaScript string, which avoids loss of precision that
-	// can happen when a large value is converted to a floating point JavaScript.
-	// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
-	// use the JavaScript "number" type.  The behavior of the default option
-	// JS_NORMAL is implementation dependent.
-	//
-	// This option is an enum to permit additional types to be added, e.g.
-	// goog.math.Integer.
-	Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
-	// Should this field be parsed lazily?  Lazy applies only to message-type
-	// fields.  It means that when the outer message is initially parsed, the
-	// inner message's contents will not be parsed but instead stored in encoded
-	// form.  The inner message will actually be parsed when it is first accessed.
-	//
-	// This is only a hint.  Implementations are free to choose whether to use
-	// eager or lazy parsing regardless of the value of this option.  However,
-	// setting this option true suggests that the protocol author believes that
-	// using lazy parsing on this field is worth the additional bookkeeping
-	// overhead typically needed to implement it.
-	//
-	// This option does not affect the public interface of any generated code;
-	// all method signatures remain the same.  Furthermore, thread-safety of the
-	// interface is not affected by this option; const methods remain safe to
-	// call from multiple threads concurrently, while non-const methods continue
-	// to require exclusive access.
-	//
-	//
-	// Note that implementations may choose not to check required fields within
-	// a lazy sub-message.  That is, calling IsInitialized() on the outer message
-	// may return true even if the inner message has missing required fields.
-	// This is necessary because otherwise the inner message would have to be
-	// parsed in order to perform the check, defeating the purpose of lazy
-	// parsing.  An implementation which chooses not to check required fields
-	// must be consistent about it.  That is, for any particular sub-message, the
-	// implementation must either *always* check its required fields, or *never*
-	// check its required fields, regardless of whether or not the message has
-	// been parsed.
-	Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"`
-	// Is this field deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for accessors, or it will be completely ignored; in the very least, this
-	// is a formalization for deprecating fields.
-	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// For Google-internal migration only. Do not use.
-	Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *FieldOptions) Reset()         { *m = FieldOptions{} }
-func (m *FieldOptions) String() string { return proto.CompactTextString(m) }
-func (*FieldOptions) ProtoMessage()    {}
-func (*FieldOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{12}
-}
-
-var extRange_FieldOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_FieldOptions
-}
-func (m *FieldOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FieldOptions.Unmarshal(m, b)
-}
-func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic)
-}
-func (dst *FieldOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FieldOptions.Merge(dst, src)
-}
-func (m *FieldOptions) XXX_Size() int {
-	return xxx_messageInfo_FieldOptions.Size(m)
-}
-func (m *FieldOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_FieldOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FieldOptions proto.InternalMessageInfo
-
-const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING
-const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL
-const Default_FieldOptions_Lazy bool = false
-const Default_FieldOptions_Deprecated bool = false
-const Default_FieldOptions_Weak bool = false
-
-func (m *FieldOptions) GetCtype() FieldOptions_CType {
-	if m != nil && m.Ctype != nil {
-		return *m.Ctype
-	}
-	return Default_FieldOptions_Ctype
-}
-
-func (m *FieldOptions) GetPacked() bool {
-	if m != nil && m.Packed != nil {
-		return *m.Packed
-	}
-	return false
-}
-
-func (m *FieldOptions) GetJstype() FieldOptions_JSType {
-	if m != nil && m.Jstype != nil {
-		return *m.Jstype
-	}
-	return Default_FieldOptions_Jstype
-}
-
-func (m *FieldOptions) GetLazy() bool {
-	if m != nil && m.Lazy != nil {
-		return *m.Lazy
-	}
-	return Default_FieldOptions_Lazy
-}
-
-func (m *FieldOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_FieldOptions_Deprecated
-}
-
-func (m *FieldOptions) GetWeak() bool {
-	if m != nil && m.Weak != nil {
-		return *m.Weak
-	}
-	return Default_FieldOptions_Weak
-}
-
-func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type OneofOptions struct {
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *OneofOptions) Reset()         { *m = OneofOptions{} }
-func (m *OneofOptions) String() string { return proto.CompactTextString(m) }
-func (*OneofOptions) ProtoMessage()    {}
-func (*OneofOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{13}
-}
-
-var extRange_OneofOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*OneofOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_OneofOptions
-}
-func (m *OneofOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_OneofOptions.Unmarshal(m, b)
-}
-func (m *OneofOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_OneofOptions.Marshal(b, m, deterministic)
-}
-func (dst *OneofOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OneofOptions.Merge(dst, src)
-}
-func (m *OneofOptions) XXX_Size() int {
-	return xxx_messageInfo_OneofOptions.Size(m)
-}
-func (m *OneofOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_OneofOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_OneofOptions proto.InternalMessageInfo
-
-func (m *OneofOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type EnumOptions struct {
-	// Set this option to true to allow mapping different tag names to the same
-	// value.
-	AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"`
-	// Is this enum deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the enum, or it will be completely ignored; in the very least, this
-	// is a formalization for deprecating enums.
-	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *EnumOptions) Reset()         { *m = EnumOptions{} }
-func (m *EnumOptions) String() string { return proto.CompactTextString(m) }
-func (*EnumOptions) ProtoMessage()    {}
-func (*EnumOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{14}
-}
-
-var extRange_EnumOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_EnumOptions
-}
-func (m *EnumOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EnumOptions.Unmarshal(m, b)
-}
-func (m *EnumOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EnumOptions.Marshal(b, m, deterministic)
-}
-func (dst *EnumOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EnumOptions.Merge(dst, src)
-}
-func (m *EnumOptions) XXX_Size() int {
-	return xxx_messageInfo_EnumOptions.Size(m)
-}
-func (m *EnumOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_EnumOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EnumOptions proto.InternalMessageInfo
-
-const Default_EnumOptions_Deprecated bool = false
-
-func (m *EnumOptions) GetAllowAlias() bool {
-	if m != nil && m.AllowAlias != nil {
-		return *m.AllowAlias
-	}
-	return false
-}
-
-func (m *EnumOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_EnumOptions_Deprecated
-}
-
-func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type EnumValueOptions struct {
-	// Is this enum value deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the enum value, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating enum values.
-	Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *EnumValueOptions) Reset()         { *m = EnumValueOptions{} }
-func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) }
-func (*EnumValueOptions) ProtoMessage()    {}
-func (*EnumValueOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{15}
-}
-
-var extRange_EnumValueOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_EnumValueOptions
-}
-func (m *EnumValueOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EnumValueOptions.Unmarshal(m, b)
-}
-func (m *EnumValueOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EnumValueOptions.Marshal(b, m, deterministic)
-}
-func (dst *EnumValueOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EnumValueOptions.Merge(dst, src)
-}
-func (m *EnumValueOptions) XXX_Size() int {
-	return xxx_messageInfo_EnumValueOptions.Size(m)
-}
-func (m *EnumValueOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_EnumValueOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EnumValueOptions proto.InternalMessageInfo
-
-const Default_EnumValueOptions_Deprecated bool = false
-
-func (m *EnumValueOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_EnumValueOptions_Deprecated
-}
-
-func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type ServiceOptions struct {
-	// Is this service deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the service, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating services.
-	Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *ServiceOptions) Reset()         { *m = ServiceOptions{} }
-func (m *ServiceOptions) String() string { return proto.CompactTextString(m) }
-func (*ServiceOptions) ProtoMessage()    {}
-func (*ServiceOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{16}
-}
-
-var extRange_ServiceOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_ServiceOptions
-}
-func (m *ServiceOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ServiceOptions.Unmarshal(m, b)
-}
-func (m *ServiceOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ServiceOptions.Marshal(b, m, deterministic)
-}
-func (dst *ServiceOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ServiceOptions.Merge(dst, src)
-}
-func (m *ServiceOptions) XXX_Size() int {
-	return xxx_messageInfo_ServiceOptions.Size(m)
-}
-func (m *ServiceOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_ServiceOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ServiceOptions proto.InternalMessageInfo
-
-const Default_ServiceOptions_Deprecated bool = false
-
-func (m *ServiceOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_ServiceOptions_Deprecated
-}
-
-func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type MethodOptions struct {
-	// Is this method deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the method, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating methods.
-	Deprecated       *bool                           `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *MethodOptions) Reset()         { *m = MethodOptions{} }
-func (m *MethodOptions) String() string { return proto.CompactTextString(m) }
-func (*MethodOptions) ProtoMessage()    {}
-func (*MethodOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{17}
-}
-
-var extRange_MethodOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_MethodOptions
-}
-func (m *MethodOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_MethodOptions.Unmarshal(m, b)
-}
-func (m *MethodOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_MethodOptions.Marshal(b, m, deterministic)
-}
-func (dst *MethodOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MethodOptions.Merge(dst, src)
-}
-func (m *MethodOptions) XXX_Size() int {
-	return xxx_messageInfo_MethodOptions.Size(m)
-}
-func (m *MethodOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_MethodOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MethodOptions proto.InternalMessageInfo
-
-const Default_MethodOptions_Deprecated bool = false
-const Default_MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN
-
-func (m *MethodOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_MethodOptions_Deprecated
-}
-
-func (m *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel {
-	if m != nil && m.IdempotencyLevel != nil {
-		return *m.IdempotencyLevel
-	}
-	return Default_MethodOptions_IdempotencyLevel
-}
-
-func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-// A message representing a option the parser does not recognize. This only
-// appears in options protos created by the compiler::Parser class.
-// DescriptorPool resolves these when building Descriptor objects. Therefore,
-// options protos in descriptor objects (e.g. returned by Descriptor::options(),
-// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
-// in them.
-type UninterpretedOption struct {
-	Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"`
-	// The value of the uninterpreted option, in whatever type the tokenizer
-	// identified it as during parsing. Exactly one of these should be set.
-	IdentifierValue      *string  `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"`
-	PositiveIntValue     *uint64  `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"`
-	NegativeIntValue     *int64   `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"`
-	DoubleValue          *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
-	StringValue          []byte   `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
-	AggregateValue       *string  `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *UninterpretedOption) Reset()         { *m = UninterpretedOption{} }
-func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) }
-func (*UninterpretedOption) ProtoMessage()    {}
-func (*UninterpretedOption) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{18}
-}
-func (m *UninterpretedOption) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_UninterpretedOption.Unmarshal(m, b)
-}
-func (m *UninterpretedOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_UninterpretedOption.Marshal(b, m, deterministic)
-}
-func (dst *UninterpretedOption) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UninterpretedOption.Merge(dst, src)
-}
-func (m *UninterpretedOption) XXX_Size() int {
-	return xxx_messageInfo_UninterpretedOption.Size(m)
-}
-func (m *UninterpretedOption) XXX_DiscardUnknown() {
-	xxx_messageInfo_UninterpretedOption.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UninterpretedOption proto.InternalMessageInfo
-
-func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
-	if m != nil {
-		return m.Name
-	}
-	return nil
-}
-
-func (m *UninterpretedOption) GetIdentifierValue() string {
-	if m != nil && m.IdentifierValue != nil {
-		return *m.IdentifierValue
-	}
-	return ""
-}
-
-func (m *UninterpretedOption) GetPositiveIntValue() uint64 {
-	if m != nil && m.PositiveIntValue != nil {
-		return *m.PositiveIntValue
-	}
-	return 0
-}
-
-func (m *UninterpretedOption) GetNegativeIntValue() int64 {
-	if m != nil && m.NegativeIntValue != nil {
-		return *m.NegativeIntValue
-	}
-	return 0
-}
-
-func (m *UninterpretedOption) GetDoubleValue() float64 {
-	if m != nil && m.DoubleValue != nil {
-		return *m.DoubleValue
-	}
-	return 0
-}
-
-func (m *UninterpretedOption) GetStringValue() []byte {
-	if m != nil {
-		return m.StringValue
-	}
-	return nil
-}
-
-func (m *UninterpretedOption) GetAggregateValue() string {
-	if m != nil && m.AggregateValue != nil {
-		return *m.AggregateValue
-	}
-	return ""
-}
-
-// The name of the uninterpreted option.  Each string represents a segment in
-// a dot-separated name.  is_extension is true iff a segment represents an
-// extension (denoted with parentheses in options specs in .proto files).
-// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
-// "foo.(bar.baz).qux".
-type UninterpretedOption_NamePart struct {
-	NamePart             *string  `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"`
-	IsExtension          *bool    `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *UninterpretedOption_NamePart) Reset()         { *m = UninterpretedOption_NamePart{} }
-func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) }
-func (*UninterpretedOption_NamePart) ProtoMessage()    {}
-func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{18, 0}
-}
-func (m *UninterpretedOption_NamePart) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_UninterpretedOption_NamePart.Unmarshal(m, b)
-}
-func (m *UninterpretedOption_NamePart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_UninterpretedOption_NamePart.Marshal(b, m, deterministic)
-}
-func (dst *UninterpretedOption_NamePart) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UninterpretedOption_NamePart.Merge(dst, src)
-}
-func (m *UninterpretedOption_NamePart) XXX_Size() int {
-	return xxx_messageInfo_UninterpretedOption_NamePart.Size(m)
-}
-func (m *UninterpretedOption_NamePart) XXX_DiscardUnknown() {
-	xxx_messageInfo_UninterpretedOption_NamePart.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UninterpretedOption_NamePart proto.InternalMessageInfo
-
-func (m *UninterpretedOption_NamePart) GetNamePart() string {
-	if m != nil && m.NamePart != nil {
-		return *m.NamePart
-	}
-	return ""
-}
-
-func (m *UninterpretedOption_NamePart) GetIsExtension() bool {
-	if m != nil && m.IsExtension != nil {
-		return *m.IsExtension
-	}
-	return false
-}
-
-// Encapsulates information about the original source file from which a
-// FileDescriptorProto was generated.
-type SourceCodeInfo struct {
-	// A Location identifies a piece of source code in a .proto file which
-	// corresponds to a particular definition.  This information is intended
-	// to be useful to IDEs, code indexers, documentation generators, and similar
-	// tools.
-	//
-	// For example, say we have a file like:
-	//   message Foo {
-	//     optional string foo = 1;
-	//   }
-	// Let's look at just the field definition:
-	//   optional string foo = 1;
-	//   ^       ^^     ^^  ^  ^^^
-	//   a       bc     de  f  ghi
-	// We have the following locations:
-	//   span   path               represents
-	//   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
-	//   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
-	//   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
-	//   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
-	//   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
-	//
-	// Notes:
-	// - A location may refer to a repeated field itself (i.e. not to any
-	//   particular index within it).  This is used whenever a set of elements are
-	//   logically enclosed in a single code segment.  For example, an entire
-	//   extend block (possibly containing multiple extension definitions) will
-	//   have an outer location whose path refers to the "extensions" repeated
-	//   field without an index.
-	// - Multiple locations may have the same path.  This happens when a single
-	//   logical declaration is spread out across multiple places.  The most
-	//   obvious example is the "extend" block again -- there may be multiple
-	//   extend blocks in the same scope, each of which will have the same path.
-	// - A location's span is not always a subset of its parent's span.  For
-	//   example, the "extendee" of an extension declaration appears at the
-	//   beginning of the "extend" block and is shared by all extensions within
-	//   the block.
-	// - Just because a location's span is a subset of some other location's span
-	//   does not mean that it is a descendent.  For example, a "group" defines
-	//   both a type and a field in a single declaration.  Thus, the locations
-	//   corresponding to the type and field and their components will overlap.
-	// - Code which tries to interpret locations should probably be designed to
-	//   ignore those that it doesn't understand, as more types of locations could
-	//   be recorded in the future.
-	Location             []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
-	XXX_unrecognized     []byte                     `json:"-"`
-	XXX_sizecache        int32                      `json:"-"`
-}
-
-func (m *SourceCodeInfo) Reset()         { *m = SourceCodeInfo{} }
-func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) }
-func (*SourceCodeInfo) ProtoMessage()    {}
-func (*SourceCodeInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{19}
-}
-func (m *SourceCodeInfo) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_SourceCodeInfo.Unmarshal(m, b)
-}
-func (m *SourceCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_SourceCodeInfo.Marshal(b, m, deterministic)
-}
-func (dst *SourceCodeInfo) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SourceCodeInfo.Merge(dst, src)
-}
-func (m *SourceCodeInfo) XXX_Size() int {
-	return xxx_messageInfo_SourceCodeInfo.Size(m)
-}
-func (m *SourceCodeInfo) XXX_DiscardUnknown() {
-	xxx_messageInfo_SourceCodeInfo.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SourceCodeInfo proto.InternalMessageInfo
-
-func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
-	if m != nil {
-		return m.Location
-	}
-	return nil
-}
-
-type SourceCodeInfo_Location struct {
-	// Identifies which part of the FileDescriptorProto was defined at this
-	// location.
-	//
-	// Each element is a field number or an index.  They form a path from
-	// the root FileDescriptorProto to the place where the definition.  For
-	// example, this path:
-	//   [ 4, 3, 2, 7, 1 ]
-	// refers to:
-	//   file.message_type(3)  // 4, 3
-	//       .field(7)         // 2, 7
-	//       .name()           // 1
-	// This is because FileDescriptorProto.message_type has field number 4:
-	//   repeated DescriptorProto message_type = 4;
-	// and DescriptorProto.field has field number 2:
-	//   repeated FieldDescriptorProto field = 2;
-	// and FieldDescriptorProto.name has field number 1:
-	//   optional string name = 1;
-	//
-	// Thus, the above path gives the location of a field name.  If we removed
-	// the last element:
-	//   [ 4, 3, 2, 7 ]
-	// this path refers to the whole field declaration (from the beginning
-	// of the label to the terminating semicolon).
-	Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
-	// Always has exactly three or four elements: start line, start column,
-	// end line (optional, otherwise assumed same as start line), end column.
-	// These are packed into a single field for efficiency.  Note that line
-	// and column numbers are zero-based -- typically you will want to add
-	// 1 to each before displaying to a user.
-	Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"`
-	// If this SourceCodeInfo represents a complete declaration, these are any
-	// comments appearing before and after the declaration which appear to be
-	// attached to the declaration.
-	//
-	// A series of line comments appearing on consecutive lines, with no other
-	// tokens appearing on those lines, will be treated as a single comment.
-	//
-	// leading_detached_comments will keep paragraphs of comments that appear
-	// before (but not connected to) the current element. Each paragraph,
-	// separated by empty lines, will be one comment element in the repeated
-	// field.
-	//
-	// Only the comment content is provided; comment markers (e.g. //) are
-	// stripped out.  For block comments, leading whitespace and an asterisk
-	// will be stripped from the beginning of each line other than the first.
-	// Newlines are included in the output.
-	//
-	// Examples:
-	//
-	//   optional int32 foo = 1;  // Comment attached to foo.
-	//   // Comment attached to bar.
-	//   optional int32 bar = 2;
-	//
-	//   optional string baz = 3;
-	//   // Comment attached to baz.
-	//   // Another line attached to baz.
-	//
-	//   // Comment attached to qux.
-	//   //
-	//   // Another line attached to qux.
-	//   optional double qux = 4;
-	//
-	//   // Detached comment for corge. This is not leading or trailing comments
-	//   // to qux or corge because there are blank lines separating it from
-	//   // both.
-	//
-	//   // Detached comment for corge paragraph 2.
-	//
-	//   optional string corge = 5;
-	//   /* Block comment attached
-	//    * to corge.  Leading asterisks
-	//    * will be removed. */
-	//   /* Block comment attached to
-	//    * grault. */
-	//   optional int32 grault = 6;
-	//
-	//   // ignored detached comments.
-	LeadingComments         *string  `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"`
-	TrailingComments        *string  `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"`
-	LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"`
-	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
-	XXX_unrecognized        []byte   `json:"-"`
-	XXX_sizecache           int32    `json:"-"`
-}
-
-func (m *SourceCodeInfo_Location) Reset()         { *m = SourceCodeInfo_Location{} }
-func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) }
-func (*SourceCodeInfo_Location) ProtoMessage()    {}
-func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{19, 0}
-}
-func (m *SourceCodeInfo_Location) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_SourceCodeInfo_Location.Unmarshal(m, b)
-}
-func (m *SourceCodeInfo_Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_SourceCodeInfo_Location.Marshal(b, m, deterministic)
-}
-func (dst *SourceCodeInfo_Location) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SourceCodeInfo_Location.Merge(dst, src)
-}
-func (m *SourceCodeInfo_Location) XXX_Size() int {
-	return xxx_messageInfo_SourceCodeInfo_Location.Size(m)
-}
-func (m *SourceCodeInfo_Location) XXX_DiscardUnknown() {
-	xxx_messageInfo_SourceCodeInfo_Location.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SourceCodeInfo_Location proto.InternalMessageInfo
-
-func (m *SourceCodeInfo_Location) GetPath() []int32 {
-	if m != nil {
-		return m.Path
-	}
-	return nil
-}
-
-func (m *SourceCodeInfo_Location) GetSpan() []int32 {
-	if m != nil {
-		return m.Span
-	}
-	return nil
-}
-
-func (m *SourceCodeInfo_Location) GetLeadingComments() string {
-	if m != nil && m.LeadingComments != nil {
-		return *m.LeadingComments
-	}
-	return ""
-}
-
-func (m *SourceCodeInfo_Location) GetTrailingComments() string {
-	if m != nil && m.TrailingComments != nil {
-		return *m.TrailingComments
-	}
-	return ""
-}
-
-func (m *SourceCodeInfo_Location) GetLeadingDetachedComments() []string {
-	if m != nil {
-		return m.LeadingDetachedComments
-	}
-	return nil
-}
-
-// Describes the relationship between generated code and its original source
-// file. A GeneratedCodeInfo message is associated with only one generated
-// source file, but may contain references to different source .proto files.
-type GeneratedCodeInfo struct {
-	// An Annotation connects some span of text in generated code to an element
-	// of its generating .proto file.
-	Annotation           []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
-	XXX_unrecognized     []byte                          `json:"-"`
-	XXX_sizecache        int32                           `json:"-"`
-}
-
-func (m *GeneratedCodeInfo) Reset()         { *m = GeneratedCodeInfo{} }
-func (m *GeneratedCodeInfo) String() string { return proto.CompactTextString(m) }
-func (*GeneratedCodeInfo) ProtoMessage()    {}
-func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{20}
-}
-func (m *GeneratedCodeInfo) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GeneratedCodeInfo.Unmarshal(m, b)
-}
-func (m *GeneratedCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GeneratedCodeInfo.Marshal(b, m, deterministic)
-}
-func (dst *GeneratedCodeInfo) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GeneratedCodeInfo.Merge(dst, src)
-}
-func (m *GeneratedCodeInfo) XXX_Size() int {
-	return xxx_messageInfo_GeneratedCodeInfo.Size(m)
-}
-func (m *GeneratedCodeInfo) XXX_DiscardUnknown() {
-	xxx_messageInfo_GeneratedCodeInfo.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GeneratedCodeInfo proto.InternalMessageInfo
-
-func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
-	if m != nil {
-		return m.Annotation
-	}
-	return nil
-}
-
-type GeneratedCodeInfo_Annotation struct {
-	// Identifies the element in the original source .proto file. This field
-	// is formatted the same as SourceCodeInfo.Location.path.
-	Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
-	// Identifies the filesystem path to the original source .proto.
-	SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
-	// Identifies the starting offset in bytes in the generated code
-	// that relates to the identified object.
-	Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"`
-	// Identifies the ending offset in bytes in the generated code that
-	// relates to the identified offset. The end offset should be one past
-	// the last relevant byte (so the length of the text = end - begin).
-	End                  *int32   `protobuf:"varint,4,opt,name=end" json:"end,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *GeneratedCodeInfo_Annotation) Reset()         { *m = GeneratedCodeInfo_Annotation{} }
-func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) }
-func (*GeneratedCodeInfo_Annotation) ProtoMessage()    {}
-func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{20, 0}
-}
-func (m *GeneratedCodeInfo_Annotation) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GeneratedCodeInfo_Annotation.Unmarshal(m, b)
-}
-func (m *GeneratedCodeInfo_Annotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GeneratedCodeInfo_Annotation.Marshal(b, m, deterministic)
-}
-func (dst *GeneratedCodeInfo_Annotation) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GeneratedCodeInfo_Annotation.Merge(dst, src)
-}
-func (m *GeneratedCodeInfo_Annotation) XXX_Size() int {
-	return xxx_messageInfo_GeneratedCodeInfo_Annotation.Size(m)
-}
-func (m *GeneratedCodeInfo_Annotation) XXX_DiscardUnknown() {
-	xxx_messageInfo_GeneratedCodeInfo_Annotation.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GeneratedCodeInfo_Annotation proto.InternalMessageInfo
-
-func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 {
-	if m != nil {
-		return m.Path
-	}
-	return nil
-}
-
-func (m *GeneratedCodeInfo_Annotation) GetSourceFile() string {
-	if m != nil && m.SourceFile != nil {
-		return *m.SourceFile
-	}
-	return ""
-}
-
-func (m *GeneratedCodeInfo_Annotation) GetBegin() int32 {
-	if m != nil && m.Begin != nil {
-		return *m.Begin
-	}
-	return 0
-}
-
-func (m *GeneratedCodeInfo_Annotation) GetEnd() int32 {
-	if m != nil && m.End != nil {
-		return *m.End
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet")
-	proto.RegisterType((*FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto")
-	proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto")
-	proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange")
-	proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange")
-	proto.RegisterType((*ExtensionRangeOptions)(nil), "google.protobuf.ExtensionRangeOptions")
-	proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto")
-	proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto")
-	proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto")
-	proto.RegisterType((*EnumDescriptorProto_EnumReservedRange)(nil), "google.protobuf.EnumDescriptorProto.EnumReservedRange")
-	proto.RegisterType((*EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto")
-	proto.RegisterType((*ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto")
-	proto.RegisterType((*MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto")
-	proto.RegisterType((*FileOptions)(nil), "google.protobuf.FileOptions")
-	proto.RegisterType((*MessageOptions)(nil), "google.protobuf.MessageOptions")
-	proto.RegisterType((*FieldOptions)(nil), "google.protobuf.FieldOptions")
-	proto.RegisterType((*OneofOptions)(nil), "google.protobuf.OneofOptions")
-	proto.RegisterType((*EnumOptions)(nil), "google.protobuf.EnumOptions")
-	proto.RegisterType((*EnumValueOptions)(nil), "google.protobuf.EnumValueOptions")
-	proto.RegisterType((*ServiceOptions)(nil), "google.protobuf.ServiceOptions")
-	proto.RegisterType((*MethodOptions)(nil), "google.protobuf.MethodOptions")
-	proto.RegisterType((*UninterpretedOption)(nil), "google.protobuf.UninterpretedOption")
-	proto.RegisterType((*UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart")
-	proto.RegisterType((*SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo")
-	proto.RegisterType((*SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location")
-	proto.RegisterType((*GeneratedCodeInfo)(nil), "google.protobuf.GeneratedCodeInfo")
-	proto.RegisterType((*GeneratedCodeInfo_Annotation)(nil), "google.protobuf.GeneratedCodeInfo.Annotation")
-	proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value)
-	proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value)
-	proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value)
-	proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value)
-	proto.RegisterEnum("google.protobuf.FieldOptions_JSType", FieldOptions_JSType_name, FieldOptions_JSType_value)
-	proto.RegisterEnum("google.protobuf.MethodOptions_IdempotencyLevel", MethodOptions_IdempotencyLevel_name, MethodOptions_IdempotencyLevel_value)
-}
-
-func init() {
-	proto.RegisterFile("google/protobuf/descriptor.proto", fileDescriptor_descriptor_4df4cb5f42392df6)
-}
-
-var fileDescriptor_descriptor_4df4cb5f42392df6 = []byte{
-	// 2555 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xdd, 0x6e, 0x1b, 0xc7,
-	0xf5, 0xcf, 0xf2, 0x4b, 0xe4, 0x21, 0x45, 0x8d, 0x46, 0x8a, 0xbd, 0x56, 0x3e, 0x2c, 0x33, 0x1f,
-	0x96, 0x9d, 0x7f, 0xa8, 0xc0, 0xb1, 0x1d, 0x47, 0xfe, 0x23, 0x2d, 0x45, 0xae, 0x15, 0xaa, 0x12,
-	0xc9, 0x2e, 0xa9, 0xe6, 0x03, 0x28, 0x16, 0xa3, 0xdd, 0x21, 0xb9, 0xf6, 0x72, 0x77, 0xb3, 0xbb,
-	0xb4, 0xad, 0xa0, 0x17, 0x06, 0x7a, 0xd5, 0xab, 0xde, 0x16, 0x45, 0xd1, 0x8b, 0xde, 0x04, 0xe8,
-	0x03, 0x14, 0xc8, 0x5d, 0x9f, 0xa0, 0x40, 0xde, 0xa0, 0x68, 0x0b, 0xb4, 0x8f, 0xd0, 0xcb, 0x62,
-	0x66, 0x76, 0x97, 0xbb, 0x24, 0x15, 0x2b, 0x01, 0xe2, 0x5c, 0x91, 0xf3, 0x9b, 0xdf, 0x39, 0x73,
-	0xe6, 0xcc, 0x99, 0x33, 0x67, 0x66, 0x61, 0x7b, 0xe4, 0x38, 0x23, 0x8b, 0xee, 0xba, 0x9e, 0x13,
-	0x38, 0xa7, 0xd3, 0xe1, 0xae, 0x41, 0x7d, 0xdd, 0x33, 0xdd, 0xc0, 0xf1, 0xea, 0x1c, 0xc3, 0x6b,
-	0x82, 0x51, 0x8f, 0x18, 0xb5, 0x63, 0x58, 0x7f, 0x60, 0x5a, 0xb4, 0x15, 0x13, 0xfb, 0x34, 0xc0,
-	0xf7, 0x20, 0x37, 0x34, 0x2d, 0x2a, 0x4b, 0xdb, 0xd9, 0x9d, 0xf2, 0xad, 0x37, 0xeb, 0x73, 0x42,
-	0xf5, 0xb4, 0x44, 0x8f, 0xc1, 0x2a, 0x97, 0xa8, 0xfd, 0x2b, 0x07, 0x1b, 0x4b, 0x7a, 0x31, 0x86,
-	0x9c, 0x4d, 0x26, 0x4c, 0xa3, 0xb4, 0x53, 0x52, 0xf9, 0x7f, 0x2c, 0xc3, 0x8a, 0x4b, 0xf4, 0x47,
-	0x64, 0x44, 0xe5, 0x0c, 0x87, 0xa3, 0x26, 0x7e, 0x1d, 0xc0, 0xa0, 0x2e, 0xb5, 0x0d, 0x6a, 0xeb,
-	0x67, 0x72, 0x76, 0x3b, 0xbb, 0x53, 0x52, 0x13, 0x08, 0x7e, 0x07, 0xd6, 0xdd, 0xe9, 0xa9, 0x65,
-	0xea, 0x5a, 0x82, 0x06, 0xdb, 0xd9, 0x9d, 0xbc, 0x8a, 0x44, 0x47, 0x6b, 0x46, 0xbe, 0x0e, 0x6b,
-	0x4f, 0x28, 0x79, 0x94, 0xa4, 0x96, 0x39, 0xb5, 0xca, 0xe0, 0x04, 0xb1, 0x09, 0x95, 0x09, 0xf5,
-	0x7d, 0x32, 0xa2, 0x5a, 0x70, 0xe6, 0x52, 0x39, 0xc7, 0x67, 0xbf, 0xbd, 0x30, 0xfb, 0xf9, 0x99,
-	0x97, 0x43, 0xa9, 0xc1, 0x99, 0x4b, 0x71, 0x03, 0x4a, 0xd4, 0x9e, 0x4e, 0x84, 0x86, 0xfc, 0x39,
-	0xfe, 0x53, 0xec, 0xe9, 0x64, 0x5e, 0x4b, 0x91, 0x89, 0x85, 0x2a, 0x56, 0x7c, 0xea, 0x3d, 0x36,
-	0x75, 0x2a, 0x17, 0xb8, 0x82, 0xeb, 0x0b, 0x0a, 0xfa, 0xa2, 0x7f, 0x5e, 0x47, 0x24, 0x87, 0x9b,
-	0x50, 0xa2, 0x4f, 0x03, 0x6a, 0xfb, 0xa6, 0x63, 0xcb, 0x2b, 0x5c, 0xc9, 0x5b, 0x4b, 0x56, 0x91,
-	0x5a, 0xc6, 0xbc, 0x8a, 0x99, 0x1c, 0xbe, 0x0b, 0x2b, 0x8e, 0x1b, 0x98, 0x8e, 0xed, 0xcb, 0xc5,
-	0x6d, 0x69, 0xa7, 0x7c, 0xeb, 0xd5, 0xa5, 0x81, 0xd0, 0x15, 0x1c, 0x35, 0x22, 0xe3, 0x36, 0x20,
-	0xdf, 0x99, 0x7a, 0x3a, 0xd5, 0x74, 0xc7, 0xa0, 0x9a, 0x69, 0x0f, 0x1d, 0xb9, 0xc4, 0x15, 0x5c,
-	0x5d, 0x9c, 0x08, 0x27, 0x36, 0x1d, 0x83, 0xb6, 0xed, 0xa1, 0xa3, 0x56, 0xfd, 0x54, 0x1b, 0x5f,
-	0x82, 0x82, 0x7f, 0x66, 0x07, 0xe4, 0xa9, 0x5c, 0xe1, 0x11, 0x12, 0xb6, 0x6a, 0x5f, 0x17, 0x60,
-	0xed, 0x22, 0x21, 0x76, 0x1f, 0xf2, 0x43, 0x36, 0x4b, 0x39, 0xf3, 0x5d, 0x7c, 0x20, 0x64, 0xd2,
-	0x4e, 0x2c, 0x7c, 0x4f, 0x27, 0x36, 0xa0, 0x6c, 0x53, 0x3f, 0xa0, 0x86, 0x88, 0x88, 0xec, 0x05,
-	0x63, 0x0a, 0x84, 0xd0, 0x62, 0x48, 0xe5, 0xbe, 0x57, 0x48, 0x7d, 0x0a, 0x6b, 0xb1, 0x49, 0x9a,
-	0x47, 0xec, 0x51, 0x14, 0x9b, 0xbb, 0xcf, 0xb3, 0xa4, 0xae, 0x44, 0x72, 0x2a, 0x13, 0x53, 0xab,
-	0x34, 0xd5, 0xc6, 0x2d, 0x00, 0xc7, 0xa6, 0xce, 0x50, 0x33, 0xa8, 0x6e, 0xc9, 0xc5, 0x73, 0xbc,
-	0xd4, 0x65, 0x94, 0x05, 0x2f, 0x39, 0x02, 0xd5, 0x2d, 0xfc, 0xe1, 0x2c, 0xd4, 0x56, 0xce, 0x89,
-	0x94, 0x63, 0xb1, 0xc9, 0x16, 0xa2, 0xed, 0x04, 0xaa, 0x1e, 0x65, 0x71, 0x4f, 0x8d, 0x70, 0x66,
-	0x25, 0x6e, 0x44, 0xfd, 0xb9, 0x33, 0x53, 0x43, 0x31, 0x31, 0xb1, 0x55, 0x2f, 0xd9, 0xc4, 0x6f,
-	0x40, 0x0c, 0x68, 0x3c, 0xac, 0x80, 0x67, 0xa1, 0x4a, 0x04, 0x76, 0xc8, 0x84, 0x6e, 0x7d, 0x09,
-	0xd5, 0xb4, 0x7b, 0xf0, 0x26, 0xe4, 0xfd, 0x80, 0x78, 0x01, 0x8f, 0xc2, 0xbc, 0x2a, 0x1a, 0x18,
-	0x41, 0x96, 0xda, 0x06, 0xcf, 0x72, 0x79, 0x95, 0xfd, 0xc5, 0x3f, 0x9d, 0x4d, 0x38, 0xcb, 0x27,
-	0xfc, 0xf6, 0xe2, 0x8a, 0xa6, 0x34, 0xcf, 0xcf, 0x7b, 0xeb, 0x03, 0x58, 0x4d, 0x4d, 0xe0, 0xa2,
-	0x43, 0xd7, 0x7e, 0x05, 0x2f, 0x2f, 0x55, 0x8d, 0x3f, 0x85, 0xcd, 0xa9, 0x6d, 0xda, 0x01, 0xf5,
-	0x5c, 0x8f, 0xb2, 0x88, 0x15, 0x43, 0xc9, 0xff, 0x5e, 0x39, 0x27, 0xe6, 0x4e, 0x92, 0x6c, 0xa1,
-	0x45, 0xdd, 0x98, 0x2e, 0x82, 0x37, 0x4b, 0xc5, 0xff, 0xac, 0xa0, 0x67, 0xcf, 0x9e, 0x3d, 0xcb,
-	0xd4, 0x7e, 0x57, 0x80, 0xcd, 0x65, 0x7b, 0x66, 0xe9, 0xf6, 0xbd, 0x04, 0x05, 0x7b, 0x3a, 0x39,
-	0xa5, 0x1e, 0x77, 0x52, 0x5e, 0x0d, 0x5b, 0xb8, 0x01, 0x79, 0x8b, 0x9c, 0x52, 0x4b, 0xce, 0x6d,
-	0x4b, 0x3b, 0xd5, 0x5b, 0xef, 0x5c, 0x68, 0x57, 0xd6, 0x8f, 0x98, 0x88, 0x2a, 0x24, 0xf1, 0x47,
-	0x90, 0x0b, 0x53, 0x34, 0xd3, 0x70, 0xf3, 0x62, 0x1a, 0xd8, 0x5e, 0x52, 0xb9, 0x1c, 0x7e, 0x05,
-	0x4a, 0xec, 0x57, 0xc4, 0x46, 0x81, 0xdb, 0x5c, 0x64, 0x00, 0x8b, 0x0b, 0xbc, 0x05, 0x45, 0xbe,
-	0x4d, 0x0c, 0x1a, 0x1d, 0x6d, 0x71, 0x9b, 0x05, 0x96, 0x41, 0x87, 0x64, 0x6a, 0x05, 0xda, 0x63,
-	0x62, 0x4d, 0x29, 0x0f, 0xf8, 0x92, 0x5a, 0x09, 0xc1, 0x5f, 0x30, 0x0c, 0x5f, 0x85, 0xb2, 0xd8,
-	0x55, 0xa6, 0x6d, 0xd0, 0xa7, 0x3c, 0x7b, 0xe6, 0x55, 0xb1, 0xd1, 0xda, 0x0c, 0x61, 0xc3, 0x3f,
-	0xf4, 0x1d, 0x3b, 0x0a, 0x4d, 0x3e, 0x04, 0x03, 0xf8, 0xf0, 0x1f, 0xcc, 0x27, 0xee, 0xd7, 0x96,
-	0x4f, 0x6f, 0x3e, 0xa6, 0x6a, 0x7f, 0xc9, 0x40, 0x8e, 0xe7, 0x8b, 0x35, 0x28, 0x0f, 0x3e, 0xeb,
-	0x29, 0x5a, 0xab, 0x7b, 0xb2, 0x7f, 0xa4, 0x20, 0x09, 0x57, 0x01, 0x38, 0xf0, 0xe0, 0xa8, 0xdb,
-	0x18, 0xa0, 0x4c, 0xdc, 0x6e, 0x77, 0x06, 0x77, 0x6f, 0xa3, 0x6c, 0x2c, 0x70, 0x22, 0x80, 0x5c,
-	0x92, 0xf0, 0xfe, 0x2d, 0x94, 0xc7, 0x08, 0x2a, 0x42, 0x41, 0xfb, 0x53, 0xa5, 0x75, 0xf7, 0x36,
-	0x2a, 0xa4, 0x91, 0xf7, 0x6f, 0xa1, 0x15, 0xbc, 0x0a, 0x25, 0x8e, 0xec, 0x77, 0xbb, 0x47, 0xa8,
-	0x18, 0xeb, 0xec, 0x0f, 0xd4, 0x76, 0xe7, 0x00, 0x95, 0x62, 0x9d, 0x07, 0x6a, 0xf7, 0xa4, 0x87,
-	0x20, 0xd6, 0x70, 0xac, 0xf4, 0xfb, 0x8d, 0x03, 0x05, 0x95, 0x63, 0xc6, 0xfe, 0x67, 0x03, 0xa5,
-	0x8f, 0x2a, 0x29, 0xb3, 0xde, 0xbf, 0x85, 0x56, 0xe3, 0x21, 0x94, 0xce, 0xc9, 0x31, 0xaa, 0xe2,
-	0x75, 0x58, 0x15, 0x43, 0x44, 0x46, 0xac, 0xcd, 0x41, 0x77, 0x6f, 0x23, 0x34, 0x33, 0x44, 0x68,
-	0x59, 0x4f, 0x01, 0x77, 0x6f, 0x23, 0x5c, 0x6b, 0x42, 0x9e, 0x47, 0x17, 0xc6, 0x50, 0x3d, 0x6a,
-	0xec, 0x2b, 0x47, 0x5a, 0xb7, 0x37, 0x68, 0x77, 0x3b, 0x8d, 0x23, 0x24, 0xcd, 0x30, 0x55, 0xf9,
-	0xf9, 0x49, 0x5b, 0x55, 0x5a, 0x28, 0x93, 0xc4, 0x7a, 0x4a, 0x63, 0xa0, 0xb4, 0x50, 0xb6, 0xa6,
-	0xc3, 0xe6, 0xb2, 0x3c, 0xb9, 0x74, 0x67, 0x24, 0x96, 0x38, 0x73, 0xce, 0x12, 0x73, 0x5d, 0x0b,
-	0x4b, 0xfc, 0xcf, 0x0c, 0x6c, 0x2c, 0x39, 0x2b, 0x96, 0x0e, 0xf2, 0x13, 0xc8, 0x8b, 0x10, 0x15,
-	0xa7, 0xe7, 0x8d, 0xa5, 0x87, 0x0e, 0x0f, 0xd8, 0x85, 0x13, 0x94, 0xcb, 0x25, 0x2b, 0x88, 0xec,
-	0x39, 0x15, 0x04, 0x53, 0xb1, 0x90, 0xd3, 0x7f, 0xb9, 0x90, 0xd3, 0xc5, 0xb1, 0x77, 0xf7, 0x22,
-	0xc7, 0x1e, 0xc7, 0xbe, 0x5b, 0x6e, 0xcf, 0x2f, 0xc9, 0xed, 0xf7, 0x61, 0x7d, 0x41, 0xd1, 0x85,
-	0x73, 0xec, 0xaf, 0x25, 0x90, 0xcf, 0x73, 0xce, 0x73, 0x32, 0x5d, 0x26, 0x95, 0xe9, 0xee, 0xcf,
-	0x7b, 0xf0, 0xda, 0xf9, 0x8b, 0xb0, 0xb0, 0xd6, 0x5f, 0x49, 0x70, 0x69, 0x79, 0xa5, 0xb8, 0xd4,
-	0x86, 0x8f, 0xa0, 0x30, 0xa1, 0xc1, 0xd8, 0x89, 0xaa, 0xa5, 0xb7, 0x97, 0x9c, 0xc1, 0xac, 0x7b,
-	0x7e, 0xb1, 0x43, 0xa9, 0xe4, 0x21, 0x9e, 0x3d, 0xaf, 0xdc, 0x13, 0xd6, 0x2c, 0x58, 0xfa, 0x9b,
-	0x0c, 0xbc, 0xbc, 0x54, 0xf9, 0x52, 0x43, 0x5f, 0x03, 0x30, 0x6d, 0x77, 0x1a, 0x88, 0x8a, 0x48,
-	0x24, 0xd8, 0x12, 0x47, 0x78, 0xf2, 0x62, 0xc9, 0x73, 0x1a, 0xc4, 0xfd, 0x59, 0xde, 0x0f, 0x02,
-	0xe2, 0x84, 0x7b, 0x33, 0x43, 0x73, 0xdc, 0xd0, 0xd7, 0xcf, 0x99, 0xe9, 0x42, 0x60, 0xbe, 0x07,
-	0x48, 0xb7, 0x4c, 0x6a, 0x07, 0x9a, 0x1f, 0x78, 0x94, 0x4c, 0x4c, 0x7b, 0xc4, 0x4f, 0x90, 0xe2,
-	0x5e, 0x7e, 0x48, 0x2c, 0x9f, 0xaa, 0x6b, 0xa2, 0xbb, 0x1f, 0xf5, 0x32, 0x09, 0x1e, 0x40, 0x5e,
-	0x42, 0xa2, 0x90, 0x92, 0x10, 0xdd, 0xb1, 0x44, 0xed, 0xeb, 0x22, 0x94, 0x13, 0x75, 0x35, 0xbe,
-	0x06, 0x95, 0x87, 0xe4, 0x31, 0xd1, 0xa2, 0xbb, 0x92, 0xf0, 0x44, 0x99, 0x61, 0xbd, 0xf0, 0xbe,
-	0xf4, 0x1e, 0x6c, 0x72, 0x8a, 0x33, 0x0d, 0xa8, 0xa7, 0xe9, 0x16, 0xf1, 0x7d, 0xee, 0xb4, 0x22,
-	0xa7, 0x62, 0xd6, 0xd7, 0x65, 0x5d, 0xcd, 0xa8, 0x07, 0xdf, 0x81, 0x0d, 0x2e, 0x31, 0x99, 0x5a,
-	0x81, 0xe9, 0x5a, 0x54, 0x63, 0xb7, 0x37, 0x9f, 0x9f, 0x24, 0xb1, 0x65, 0xeb, 0x8c, 0x71, 0x1c,
-	0x12, 0x98, 0x45, 0x3e, 0x6e, 0xc1, 0x6b, 0x5c, 0x6c, 0x44, 0x6d, 0xea, 0x91, 0x80, 0x6a, 0xf4,
-	0x8b, 0x29, 0xb1, 0x7c, 0x8d, 0xd8, 0x86, 0x36, 0x26, 0xfe, 0x58, 0xde, 0x64, 0x0a, 0xf6, 0x33,
-	0xb2, 0xa4, 0x5e, 0x61, 0xc4, 0x83, 0x90, 0xa7, 0x70, 0x5a, 0xc3, 0x36, 0x3e, 0x26, 0xfe, 0x18,
-	0xef, 0xc1, 0x25, 0xae, 0xc5, 0x0f, 0x3c, 0xd3, 0x1e, 0x69, 0xfa, 0x98, 0xea, 0x8f, 0xb4, 0x69,
-	0x30, 0xbc, 0x27, 0xbf, 0x92, 0x1c, 0x9f, 0x5b, 0xd8, 0xe7, 0x9c, 0x26, 0xa3, 0x9c, 0x04, 0xc3,
-	0x7b, 0xb8, 0x0f, 0x15, 0xb6, 0x18, 0x13, 0xf3, 0x4b, 0xaa, 0x0d, 0x1d, 0x8f, 0x1f, 0x8d, 0xd5,
-	0x25, 0xa9, 0x29, 0xe1, 0xc1, 0x7a, 0x37, 0x14, 0x38, 0x76, 0x0c, 0xba, 0x97, 0xef, 0xf7, 0x14,
-	0xa5, 0xa5, 0x96, 0x23, 0x2d, 0x0f, 0x1c, 0x8f, 0x05, 0xd4, 0xc8, 0x89, 0x1d, 0x5c, 0x16, 0x01,
-	0x35, 0x72, 0x22, 0xf7, 0xde, 0x81, 0x0d, 0x5d, 0x17, 0x73, 0x36, 0x75, 0x2d, 0xbc, 0x63, 0xf9,
-	0x32, 0x4a, 0x39, 0x4b, 0xd7, 0x0f, 0x04, 0x21, 0x8c, 0x71, 0x1f, 0x7f, 0x08, 0x2f, 0xcf, 0x9c,
-	0x95, 0x14, 0x5c, 0x5f, 0x98, 0xe5, 0xbc, 0xe8, 0x1d, 0xd8, 0x70, 0xcf, 0x16, 0x05, 0x71, 0x6a,
-	0x44, 0xf7, 0x6c, 0x5e, 0xec, 0x03, 0xd8, 0x74, 0xc7, 0xee, 0xa2, 0xdc, 0xcd, 0xa4, 0x1c, 0x76,
-	0xc7, 0xee, 0xbc, 0xe0, 0x5b, 0xfc, 0xc2, 0xed, 0x51, 0x9d, 0x04, 0xd4, 0x90, 0x2f, 0x27, 0xe9,
-	0x89, 0x0e, 0xbc, 0x0b, 0x48, 0xd7, 0x35, 0x6a, 0x93, 0x53, 0x8b, 0x6a, 0xc4, 0xa3, 0x36, 0xf1,
-	0xe5, 0xab, 0x49, 0x72, 0x55, 0xd7, 0x15, 0xde, 0xdb, 0xe0, 0x9d, 0xf8, 0x26, 0xac, 0x3b, 0xa7,
-	0x0f, 0x75, 0x11, 0x92, 0x9a, 0xeb, 0xd1, 0xa1, 0xf9, 0x54, 0x7e, 0x93, 0xfb, 0x77, 0x8d, 0x75,
-	0xf0, 0x80, 0xec, 0x71, 0x18, 0xdf, 0x00, 0xa4, 0xfb, 0x63, 0xe2, 0xb9, 0x3c, 0x27, 0xfb, 0x2e,
-	0xd1, 0xa9, 0xfc, 0x96, 0xa0, 0x0a, 0xbc, 0x13, 0xc1, 0x6c, 0x4b, 0xf8, 0x4f, 0xcc, 0x61, 0x10,
-	0x69, 0xbc, 0x2e, 0xb6, 0x04, 0xc7, 0x42, 0x6d, 0x3b, 0x80, 0x98, 0x2b, 0x52, 0x03, 0xef, 0x70,
-	0x5a, 0xd5, 0x1d, 0xbb, 0xc9, 0x71, 0xdf, 0x80, 0x55, 0xc6, 0x9c, 0x0d, 0x7a, 0x43, 0x14, 0x64,
-	0xee, 0x38, 0x31, 0xe2, 0x0f, 0x56, 0x1b, 0xd7, 0xf6, 0xa0, 0x92, 0x8c, 0x4f, 0x5c, 0x02, 0x11,
-	0xa1, 0x48, 0x62, 0xc5, 0x4a, 0xb3, 0xdb, 0x62, 0x65, 0xc6, 0xe7, 0x0a, 0xca, 0xb0, 0x72, 0xe7,
-	0xa8, 0x3d, 0x50, 0x34, 0xf5, 0xa4, 0x33, 0x68, 0x1f, 0x2b, 0x28, 0x9b, 0xa8, 0xab, 0x0f, 0x73,
-	0xc5, 0xb7, 0xd1, 0xf5, 0xda, 0x37, 0x19, 0xa8, 0xa6, 0x2f, 0x4a, 0xf8, 0xff, 0xe1, 0x72, 0xf4,
-	0xaa, 0xe1, 0xd3, 0x40, 0x7b, 0x62, 0x7a, 0x7c, 0xe3, 0x4c, 0x88, 0x38, 0xc4, 0xe2, 0xa5, 0xdb,
-	0x0c, 0x59, 0x7d, 0x1a, 0x7c, 0x62, 0x7a, 0x6c, 0x5b, 0x4c, 0x48, 0x80, 0x8f, 0xe0, 0xaa, 0xed,
-	0x68, 0x7e, 0x40, 0x6c, 0x83, 0x78, 0x86, 0x36, 0x7b, 0x4f, 0xd2, 0x88, 0xae, 0x53, 0xdf, 0x77,
-	0xc4, 0x81, 0x15, 0x6b, 0x79, 0xd5, 0x76, 0xfa, 0x21, 0x79, 0x96, 0xc9, 0x1b, 0x21, 0x75, 0x2e,
-	0xcc, 0xb2, 0xe7, 0x85, 0xd9, 0x2b, 0x50, 0x9a, 0x10, 0x57, 0xa3, 0x76, 0xe0, 0x9d, 0xf1, 0xf2,
-	0xb8, 0xa8, 0x16, 0x27, 0xc4, 0x55, 0x58, 0xfb, 0x85, 0xdc, 0x52, 0x0e, 0x73, 0xc5, 0x22, 0x2a,
-	0x1d, 0xe6, 0x8a, 0x25, 0x04, 0xb5, 0x7f, 0x64, 0xa1, 0x92, 0x2c, 0x97, 0xd9, 0xed, 0x43, 0xe7,
-	0x27, 0x8b, 0xc4, 0x73, 0xcf, 0x1b, 0xdf, 0x5a, 0x5c, 0xd7, 0x9b, 0xec, 0xc8, 0xd9, 0x2b, 0x88,
-	0x22, 0x56, 0x15, 0x92, 0xec, 0xb8, 0x67, 0xd9, 0x86, 0x8a, 0xa2, 0xa1, 0xa8, 0x86, 0x2d, 0x7c,
-	0x00, 0x85, 0x87, 0x3e, 0xd7, 0x5d, 0xe0, 0xba, 0xdf, 0xfc, 0x76, 0xdd, 0x87, 0x7d, 0xae, 0xbc,
-	0x74, 0xd8, 0xd7, 0x3a, 0x5d, 0xf5, 0xb8, 0x71, 0xa4, 0x86, 0xe2, 0xf8, 0x0a, 0xe4, 0x2c, 0xf2,
-	0xe5, 0x59, 0xfa, 0x70, 0xe2, 0xd0, 0x45, 0x17, 0xe1, 0x0a, 0xe4, 0x9e, 0x50, 0xf2, 0x28, 0x7d,
-	0x24, 0x70, 0xe8, 0x07, 0xdc, 0x0c, 0xbb, 0x90, 0xe7, 0xfe, 0xc2, 0x00, 0xa1, 0xc7, 0xd0, 0x4b,
-	0xb8, 0x08, 0xb9, 0x66, 0x57, 0x65, 0x1b, 0x02, 0x41, 0x45, 0xa0, 0x5a, 0xaf, 0xad, 0x34, 0x15,
-	0x94, 0xa9, 0xdd, 0x81, 0x82, 0x70, 0x02, 0xdb, 0x2c, 0xb1, 0x1b, 0xd0, 0x4b, 0x61, 0x33, 0xd4,
-	0x21, 0x45, 0xbd, 0x27, 0xc7, 0xfb, 0x8a, 0x8a, 0x32, 0xe9, 0xa5, 0xce, 0xa1, 0x7c, 0xcd, 0x87,
-	0x4a, 0xb2, 0x5e, 0x7e, 0x31, 0x77, 0xe1, 0xbf, 0x4a, 0x50, 0x4e, 0xd4, 0xbf, 0xac, 0x70, 0x21,
-	0x96, 0xe5, 0x3c, 0xd1, 0x88, 0x65, 0x12, 0x3f, 0x0c, 0x0d, 0xe0, 0x50, 0x83, 0x21, 0x17, 0x5d,
-	0xba, 0x17, 0xb4, 0x45, 0xf2, 0xa8, 0x50, 0xfb, 0xa3, 0x04, 0x68, 0xbe, 0x00, 0x9d, 0x33, 0x53,
-	0xfa, 0x31, 0xcd, 0xac, 0xfd, 0x41, 0x82, 0x6a, 0xba, 0xea, 0x9c, 0x33, 0xef, 0xda, 0x8f, 0x6a,
-	0xde, 0xdf, 0x33, 0xb0, 0x9a, 0xaa, 0x35, 0x2f, 0x6a, 0xdd, 0x17, 0xb0, 0x6e, 0x1a, 0x74, 0xe2,
-	0x3a, 0x01, 0xb5, 0xf5, 0x33, 0xcd, 0xa2, 0x8f, 0xa9, 0x25, 0xd7, 0x78, 0xd2, 0xd8, 0xfd, 0xf6,
-	0x6a, 0xb6, 0xde, 0x9e, 0xc9, 0x1d, 0x31, 0xb1, 0xbd, 0x8d, 0x76, 0x4b, 0x39, 0xee, 0x75, 0x07,
-	0x4a, 0xa7, 0xf9, 0x99, 0x76, 0xd2, 0xf9, 0x59, 0xa7, 0xfb, 0x49, 0x47, 0x45, 0xe6, 0x1c, 0xed,
-	0x07, 0xdc, 0xf6, 0x3d, 0x40, 0xf3, 0x46, 0xe1, 0xcb, 0xb0, 0xcc, 0x2c, 0xf4, 0x12, 0xde, 0x80,
-	0xb5, 0x4e, 0x57, 0xeb, 0xb7, 0x5b, 0x8a, 0xa6, 0x3c, 0x78, 0xa0, 0x34, 0x07, 0x7d, 0xf1, 0x3e,
-	0x11, 0xb3, 0x07, 0xa9, 0x0d, 0x5e, 0xfb, 0x7d, 0x16, 0x36, 0x96, 0x58, 0x82, 0x1b, 0xe1, 0xcd,
-	0x42, 0x5c, 0x76, 0xde, 0xbd, 0x88, 0xf5, 0x75, 0x56, 0x10, 0xf4, 0x88, 0x17, 0x84, 0x17, 0x91,
-	0x1b, 0xc0, 0xbc, 0x64, 0x07, 0xe6, 0xd0, 0xa4, 0x5e, 0xf8, 0x9c, 0x23, 0xae, 0x1b, 0x6b, 0x33,
-	0x5c, 0xbc, 0xe8, 0xfc, 0x1f, 0x60, 0xd7, 0xf1, 0xcd, 0xc0, 0x7c, 0x4c, 0x35, 0xd3, 0x8e, 0xde,
-	0x7e, 0xd8, 0xf5, 0x23, 0xa7, 0xa2, 0xa8, 0xa7, 0x6d, 0x07, 0x31, 0xdb, 0xa6, 0x23, 0x32, 0xc7,
-	0x66, 0xc9, 0x3c, 0xab, 0xa2, 0xa8, 0x27, 0x66, 0x5f, 0x83, 0x8a, 0xe1, 0x4c, 0x59, 0x4d, 0x26,
-	0x78, 0xec, 0xec, 0x90, 0xd4, 0xb2, 0xc0, 0x62, 0x4a, 0x58, 0x6d, 0xcf, 0x1e, 0x9d, 0x2a, 0x6a,
-	0x59, 0x60, 0x82, 0x72, 0x1d, 0xd6, 0xc8, 0x68, 0xe4, 0x31, 0xe5, 0x91, 0x22, 0x71, 0x7f, 0xa8,
-	0xc6, 0x30, 0x27, 0x6e, 0x1d, 0x42, 0x31, 0xf2, 0x03, 0x3b, 0xaa, 0x99, 0x27, 0x34, 0x57, 0x5c,
-	0x8a, 0x33, 0x3b, 0x25, 0xb5, 0x68, 0x47, 0x9d, 0xd7, 0xa0, 0x62, 0xfa, 0xda, 0xec, 0x0d, 0x3d,
-	0xb3, 0x9d, 0xd9, 0x29, 0xaa, 0x65, 0xd3, 0x8f, 0xdf, 0x1f, 0x6b, 0x5f, 0x65, 0xa0, 0x9a, 0xfe,
-	0x06, 0x80, 0x5b, 0x50, 0xb4, 0x1c, 0x9d, 0xf0, 0xd0, 0x12, 0x1f, 0xa0, 0x76, 0x9e, 0xf3, 0xd9,
-	0xa0, 0x7e, 0x14, 0xf2, 0xd5, 0x58, 0x72, 0xeb, 0x6f, 0x12, 0x14, 0x23, 0x18, 0x5f, 0x82, 0x9c,
-	0x4b, 0x82, 0x31, 0x57, 0x97, 0xdf, 0xcf, 0x20, 0x49, 0xe5, 0x6d, 0x86, 0xfb, 0x2e, 0xb1, 0x79,
-	0x08, 0x84, 0x38, 0x6b, 0xb3, 0x75, 0xb5, 0x28, 0x31, 0xf8, 0xe5, 0xc4, 0x99, 0x4c, 0xa8, 0x1d,
-	0xf8, 0xd1, 0xba, 0x86, 0x78, 0x33, 0x84, 0xf1, 0x3b, 0xb0, 0x1e, 0x78, 0xc4, 0xb4, 0x52, 0xdc,
-	0x1c, 0xe7, 0xa2, 0xa8, 0x23, 0x26, 0xef, 0xc1, 0x95, 0x48, 0xaf, 0x41, 0x03, 0xa2, 0x8f, 0xa9,
-	0x31, 0x13, 0x2a, 0xf0, 0x47, 0x88, 0xcb, 0x21, 0xa1, 0x15, 0xf6, 0x47, 0xb2, 0xb5, 0x6f, 0x24,
-	0x58, 0x8f, 0xae, 0x53, 0x46, 0xec, 0xac, 0x63, 0x00, 0x62, 0xdb, 0x4e, 0x90, 0x74, 0xd7, 0x62,
-	0x28, 0x2f, 0xc8, 0xd5, 0x1b, 0xb1, 0x90, 0x9a, 0x50, 0xb0, 0x35, 0x01, 0x98, 0xf5, 0x9c, 0xeb,
-	0xb6, 0xab, 0x50, 0x0e, 0x3f, 0xf0, 0xf0, 0xaf, 0x84, 0xe2, 0x02, 0x0e, 0x02, 0x62, 0xf7, 0x2e,
-	0xbc, 0x09, 0xf9, 0x53, 0x3a, 0x32, 0xed, 0xf0, 0xd9, 0x56, 0x34, 0xa2, 0x67, 0x92, 0x5c, 0xfc,
-	0x4c, 0xb2, 0xff, 0x5b, 0x09, 0x36, 0x74, 0x67, 0x32, 0x6f, 0xef, 0x3e, 0x9a, 0x7b, 0x05, 0xf0,
-	0x3f, 0x96, 0x3e, 0xff, 0x68, 0x64, 0x06, 0xe3, 0xe9, 0x69, 0x5d, 0x77, 0x26, 0xbb, 0x23, 0xc7,
-	0x22, 0xf6, 0x68, 0xf6, 0x99, 0x93, 0xff, 0xd1, 0xdf, 0x1d, 0x51, 0xfb, 0xdd, 0x91, 0x93, 0xf8,
-	0xe8, 0x79, 0x7f, 0xf6, 0xf7, 0xbf, 0x92, 0xf4, 0xa7, 0x4c, 0xf6, 0xa0, 0xb7, 0xff, 0xe7, 0xcc,
-	0xd6, 0x81, 0x18, 0xae, 0x17, 0xb9, 0x47, 0xa5, 0x43, 0x8b, 0xea, 0x6c, 0xca, 0xff, 0x0b, 0x00,
-	0x00, 0xff, 0xff, 0x1a, 0x28, 0x25, 0x79, 0x42, 0x1d, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
deleted file mode 100644
index 8697a50de4a..00000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
+++ /dev/null
@@ -1,872 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Author: kenton@google.com (Kenton Varda)
-//  Based on original Protocol Buffers design by
-//  Sanjay Ghemawat, Jeff Dean, and others.
-//
-// The messages in this file describe the definitions found in .proto files.
-// A valid .proto file can be translated directly to a FileDescriptorProto
-// without any other information (e.g. without reading its imports).
-
-
-syntax = "proto2";
-
-package google.protobuf;
-option go_package = "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor";
-option java_package = "com.google.protobuf";
-option java_outer_classname = "DescriptorProtos";
-option csharp_namespace = "Google.Protobuf.Reflection";
-option objc_class_prefix = "GPB";
-option cc_enable_arenas = true;
-
-// descriptor.proto must be optimized for speed because reflection-based
-// algorithms don't work during bootstrapping.
-option optimize_for = SPEED;
-
-// The protocol compiler can output a FileDescriptorSet containing the .proto
-// files it parses.
-message FileDescriptorSet {
-  repeated FileDescriptorProto file = 1;
-}
-
-// Describes a complete .proto file.
-message FileDescriptorProto {
-  optional string name = 1;       // file name, relative to root of source tree
-  optional string package = 2;    // e.g. "foo", "foo.bar", etc.
-
-  // Names of files imported by this file.
-  repeated string dependency = 3;
-  // Indexes of the public imported files in the dependency list above.
-  repeated int32 public_dependency = 10;
-  // Indexes of the weak imported files in the dependency list.
-  // For Google-internal migration only. Do not use.
-  repeated int32 weak_dependency = 11;
-
-  // All top-level definitions in this file.
-  repeated DescriptorProto message_type = 4;
-  repeated EnumDescriptorProto enum_type = 5;
-  repeated ServiceDescriptorProto service = 6;
-  repeated FieldDescriptorProto extension = 7;
-
-  optional FileOptions options = 8;
-
-  // This field contains optional information about the original source code.
-  // You may safely remove this entire field without harming runtime
-  // functionality of the descriptors -- the information is needed only by
-  // development tools.
-  optional SourceCodeInfo source_code_info = 9;
-
-  // The syntax of the proto file.
-  // The supported values are "proto2" and "proto3".
-  optional string syntax = 12;
-}
-
-// Describes a message type.
-message DescriptorProto {
-  optional string name = 1;
-
-  repeated FieldDescriptorProto field = 2;
-  repeated FieldDescriptorProto extension = 6;
-
-  repeated DescriptorProto nested_type = 3;
-  repeated EnumDescriptorProto enum_type = 4;
-
-  message ExtensionRange {
-    optional int32 start = 1;
-    optional int32 end = 2;
-
-    optional ExtensionRangeOptions options = 3;
-  }
-  repeated ExtensionRange extension_range = 5;
-
-  repeated OneofDescriptorProto oneof_decl = 8;
-
-  optional MessageOptions options = 7;
-
-  // Range of reserved tag numbers. Reserved tag numbers may not be used by
-  // fields or extension ranges in the same message. Reserved ranges may
-  // not overlap.
-  message ReservedRange {
-    optional int32 start = 1; // Inclusive.
-    optional int32 end = 2;   // Exclusive.
-  }
-  repeated ReservedRange reserved_range = 9;
-  // Reserved field names, which may not be used by fields in the same message.
-  // A given name may only be reserved once.
-  repeated string reserved_name = 10;
-}
-
-message ExtensionRangeOptions {
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-// Describes a field within a message.
-message FieldDescriptorProto {
-  enum Type {
-    // 0 is reserved for errors.
-    // Order is weird for historical reasons.
-    TYPE_DOUBLE         = 1;
-    TYPE_FLOAT          = 2;
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
-    // negative values are likely.
-    TYPE_INT64          = 3;
-    TYPE_UINT64         = 4;
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
-    // negative values are likely.
-    TYPE_INT32          = 5;
-    TYPE_FIXED64        = 6;
-    TYPE_FIXED32        = 7;
-    TYPE_BOOL           = 8;
-    TYPE_STRING         = 9;
-    // Tag-delimited aggregate.
-    // Group type is deprecated and not supported in proto3. However, Proto3
-    // implementations should still be able to parse the group wire format and
-    // treat group fields as unknown fields.
-    TYPE_GROUP          = 10;
-    TYPE_MESSAGE        = 11;  // Length-delimited aggregate.
-
-    // New in version 2.
-    TYPE_BYTES          = 12;
-    TYPE_UINT32         = 13;
-    TYPE_ENUM           = 14;
-    TYPE_SFIXED32       = 15;
-    TYPE_SFIXED64       = 16;
-    TYPE_SINT32         = 17;  // Uses ZigZag encoding.
-    TYPE_SINT64         = 18;  // Uses ZigZag encoding.
-  };
-
-  enum Label {
-    // 0 is reserved for errors
-    LABEL_OPTIONAL      = 1;
-    LABEL_REQUIRED      = 2;
-    LABEL_REPEATED      = 3;
-  };
-
-  optional string name = 1;
-  optional int32 number = 3;
-  optional Label label = 4;
-
-  // If type_name is set, this need not be set.  If both this and type_name
-  // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
-  optional Type type = 5;
-
-  // For message and enum types, this is the name of the type.  If the name
-  // starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
-  // rules are used to find the type (i.e. first the nested types within this
-  // message are searched, then within the parent, on up to the root
-  // namespace).
-  optional string type_name = 6;
-
-  // For extensions, this is the name of the type being extended.  It is
-  // resolved in the same manner as type_name.
-  optional string extendee = 2;
-
-  // For numeric types, contains the original text representation of the value.
-  // For booleans, "true" or "false".
-  // For strings, contains the default text contents (not escaped in any way).
-  // For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
-  // TODO(kenton):  Base-64 encode?
-  optional string default_value = 7;
-
-  // If set, gives the index of a oneof in the containing type's oneof_decl
-  // list.  This field is a member of that oneof.
-  optional int32 oneof_index = 9;
-
-  // JSON name of this field. The value is set by protocol compiler. If the
-  // user has set a "json_name" option on this field, that option's value
-  // will be used. Otherwise, it's deduced from the field's name by converting
-  // it to camelCase.
-  optional string json_name = 10;
-
-  optional FieldOptions options = 8;
-}
-
-// Describes a oneof.
-message OneofDescriptorProto {
-  optional string name = 1;
-  optional OneofOptions options = 2;
-}
-
-// Describes an enum type.
-message EnumDescriptorProto {
-  optional string name = 1;
-
-  repeated EnumValueDescriptorProto value = 2;
-
-  optional EnumOptions options = 3;
-
-  // Range of reserved numeric values. Reserved values may not be used by
-  // entries in the same enum. Reserved ranges may not overlap.
-  //
-  // Note that this is distinct from DescriptorProto.ReservedRange in that it
-  // is inclusive such that it can appropriately represent the entire int32
-  // domain.
-  message EnumReservedRange {
-    optional int32 start = 1; // Inclusive.
-    optional int32 end = 2;   // Inclusive.
-  }
-
-  // Range of reserved numeric values. Reserved numeric values may not be used
-  // by enum values in the same enum declaration. Reserved ranges may not
-  // overlap.
-  repeated EnumReservedRange reserved_range = 4;
-
-  // Reserved enum value names, which may not be reused. A given name may only
-  // be reserved once.
-  repeated string reserved_name = 5;
-}
-
-// Describes a value within an enum.
-message EnumValueDescriptorProto {
-  optional string name = 1;
-  optional int32 number = 2;
-
-  optional EnumValueOptions options = 3;
-}
-
-// Describes a service.
-message ServiceDescriptorProto {
-  optional string name = 1;
-  repeated MethodDescriptorProto method = 2;
-
-  optional ServiceOptions options = 3;
-}
-
-// Describes a method of a service.
-message MethodDescriptorProto {
-  optional string name = 1;
-
-  // Input and output type names.  These are resolved in the same way as
-  // FieldDescriptorProto.type_name, but must refer to a message type.
-  optional string input_type = 2;
-  optional string output_type = 3;
-
-  optional MethodOptions options = 4;
-
-  // Identifies if client streams multiple client messages
-  optional bool client_streaming = 5 [default=false];
-  // Identifies if server streams multiple server messages
-  optional bool server_streaming = 6 [default=false];
-}
-
-
-// ===================================================================
-// Options
-
-// Each of the definitions above may have "options" attached.  These are
-// just annotations which may cause code to be generated slightly differently
-// or may contain hints for code that manipulates protocol messages.
-//
-// Clients may define custom options as extensions of the *Options messages.
-// These extensions may not yet be known at parsing time, so the parser cannot
-// store the values in them.  Instead it stores them in a field in the *Options
-// message called uninterpreted_option. This field must have the same name
-// across all *Options messages. We then use this field to populate the
-// extensions when we build a descriptor, at which point all protos have been
-// parsed and so all extensions are known.
-//
-// Extension numbers for custom options may be chosen as follows:
-// * For options which will only be used within a single application or
-//   organization, or for experimental options, use field numbers 50000
-//   through 99999.  It is up to you to ensure that you do not use the
-//   same number for multiple options.
-// * For options which will be published and used publicly by multiple
-//   independent entities, e-mail protobuf-global-extension-registry@google.com
-//   to reserve extension numbers. Simply provide your project name (e.g.
-//   Objective-C plugin) and your project website (if available) -- there's no
-//   need to explain how you intend to use them. Usually you only need one
-//   extension number. You can declare multiple options with only one extension
-//   number by putting them in a sub-message. See the Custom Options section of
-//   the docs for examples:
-//   https://developers.google.com/protocol-buffers/docs/proto#options
-//   If this turns out to be popular, a web service will be set up
-//   to automatically assign option numbers.
-
-
-message FileOptions {
-
-  // Sets the Java package where classes generated from this .proto will be
-  // placed.  By default, the proto package is used, but this is often
-  // inappropriate because proto packages do not normally start with backwards
-  // domain names.
-  optional string java_package = 1;
-
-
-  // If set, all the classes from the .proto file are wrapped in a single
-  // outer class with the given name.  This applies to both Proto1
-  // (equivalent to the old "--one_java_file" option) and Proto2 (where
-  // a .proto always translates to a single class, but you may want to
-  // explicitly choose the class name).
-  optional string java_outer_classname = 8;
-
-  // If set true, then the Java code generator will generate a separate .java
-  // file for each top-level message, enum, and service defined in the .proto
-  // file.  Thus, these types will *not* be nested inside the outer class
-  // named by java_outer_classname.  However, the outer class will still be
-  // generated to contain the file's getDescriptor() method as well as any
-  // top-level extensions defined in the file.
-  optional bool java_multiple_files = 10 [default=false];
-
-  // This option does nothing.
-  optional bool java_generate_equals_and_hash = 20 [deprecated=true];
-
-  // If set true, then the Java2 code generator will generate code that
-  // throws an exception whenever an attempt is made to assign a non-UTF-8
-  // byte sequence to a string field.
-  // Message reflection will do the same.
-  // However, an extension field still accepts non-UTF-8 byte sequences.
-  // This option has no effect on when used with the lite runtime.
-  optional bool java_string_check_utf8 = 27 [default=false];
-
-
-  // Generated classes can be optimized for speed or code size.
-  enum OptimizeMode {
-    SPEED = 1;        // Generate complete code for parsing, serialization,
-                      // etc.
-    CODE_SIZE = 2;    // Use ReflectionOps to implement these methods.
-    LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
-  }
-  optional OptimizeMode optimize_for = 9 [default=SPEED];
-
-  // Sets the Go package where structs generated from this .proto will be
-  // placed. If omitted, the Go package will be derived from the following:
-  //   - The basename of the package import path, if provided.
-  //   - Otherwise, the package statement in the .proto file, if present.
-  //   - Otherwise, the basename of the .proto file, without extension.
-  optional string go_package = 11;
-
-
-
-  // Should generic services be generated in each language?  "Generic" services
-  // are not specific to any particular RPC system.  They are generated by the
-  // main code generators in each language (without additional plugins).
-  // Generic services were the only kind of service generation supported by
-  // early versions of google.protobuf.
-  //
-  // Generic services are now considered deprecated in favor of using plugins
-  // that generate code specific to your particular RPC system.  Therefore,
-  // these default to false.  Old code which depends on generic services should
-  // explicitly set them to true.
-  optional bool cc_generic_services = 16 [default=false];
-  optional bool java_generic_services = 17 [default=false];
-  optional bool py_generic_services = 18 [default=false];
-  optional bool php_generic_services = 42 [default=false];
-
-  // Is this file deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for everything in the file, or it will be completely ignored; in the very
-  // least, this is a formalization for deprecating files.
-  optional bool deprecated = 23 [default=false];
-
-  // Enables the use of arenas for the proto messages in this file. This applies
-  // only to generated classes for C++.
-  optional bool cc_enable_arenas = 31 [default=false];
-
-
-  // Sets the objective c class prefix which is prepended to all objective c
-  // generated classes from this .proto. There is no default.
-  optional string objc_class_prefix = 36;
-
-  // Namespace for generated classes; defaults to the package.
-  optional string csharp_namespace = 37;
-
-  // By default Swift generators will take the proto package and CamelCase it
-  // replacing '.' with underscore and use that to prefix the types/symbols
-  // defined. When this options is provided, they will use this value instead
-  // to prefix the types/symbols defined.
-  optional string swift_prefix = 39;
-
-  // Sets the php class prefix which is prepended to all php generated classes
-  // from this .proto. Default is empty.
-  optional string php_class_prefix = 40;
-
-  // Use this option to change the namespace of php generated classes. Default
-  // is empty. When this option is empty, the package name will be used for
-  // determining the namespace.
-  optional string php_namespace = 41;
-
-  // The parser stores options it doesn't recognize here.
-  // See the documentation for the "Options" section above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message.
-  // See the documentation for the "Options" section above.
-  extensions 1000 to max;
-
-  reserved 38;
-}
-
-message MessageOptions {
-  // Set true to use the old proto1 MessageSet wire format for extensions.
-  // This is provided for backwards-compatibility with the MessageSet wire
-  // format.  You should not use this for any other reason:  It's less
-  // efficient, has fewer features, and is more complicated.
-  //
-  // The message must be defined exactly as follows:
-  //   message Foo {
-  //     option message_set_wire_format = true;
-  //     extensions 4 to max;
-  //   }
-  // Note that the message cannot have any defined fields; MessageSets only
-  // have extensions.
-  //
-  // All extensions of your type must be singular messages; e.g. they cannot
-  // be int32s, enums, or repeated messages.
-  //
-  // Because this is an option, the above two restrictions are not enforced by
-  // the protocol compiler.
-  optional bool message_set_wire_format = 1 [default=false];
-
-  // Disables the generation of the standard "descriptor()" accessor, which can
-  // conflict with a field of the same name.  This is meant to make migration
-  // from proto1 easier; new code should avoid fields named "descriptor".
-  optional bool no_standard_descriptor_accessor = 2 [default=false];
-
-  // Is this message deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the message, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating messages.
-  optional bool deprecated = 3 [default=false];
-
-  // Whether the message is an automatically generated map entry type for the
-  // maps field.
-  //
-  // For maps fields:
-  //     map<KeyType, ValueType> map_field = 1;
-  // The parsed descriptor looks like:
-  //     message MapFieldEntry {
-  //         option map_entry = true;
-  //         optional KeyType key = 1;
-  //         optional ValueType value = 2;
-  //     }
-  //     repeated MapFieldEntry map_field = 1;
-  //
-  // Implementations may choose not to generate the map_entry=true message, but
-  // use a native map in the target language to hold the keys and values.
-  // The reflection APIs in such implementions still need to work as
-  // if the field is a repeated message field.
-  //
-  // NOTE: Do not set the option in .proto files. Always use the maps syntax
-  // instead. The option should only be implicitly set by the proto compiler
-  // parser.
-  optional bool map_entry = 7;
-
-  reserved 8;  // javalite_serializable
-  reserved 9;  // javanano_as_lite
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message FieldOptions {
-  // The ctype option instructs the C++ code generator to use a different
-  // representation of the field than it normally would.  See the specific
-  // options below.  This option is not yet implemented in the open source
-  // release -- sorry, we'll try to include it in a future version!
-  optional CType ctype = 1 [default = STRING];
-  enum CType {
-    // Default mode.
-    STRING = 0;
-
-    CORD = 1;
-
-    STRING_PIECE = 2;
-  }
-  // The packed option can be enabled for repeated primitive fields to enable
-  // a more efficient representation on the wire. Rather than repeatedly
-  // writing the tag and type for each element, the entire array is encoded as
-  // a single length-delimited blob. In proto3, only explicit setting it to
-  // false will avoid using packed encoding.
-  optional bool packed = 2;
-
-  // The jstype option determines the JavaScript type used for values of the
-  // field.  The option is permitted only for 64 bit integral and fixed types
-  // (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
-  // is represented as JavaScript string, which avoids loss of precision that
-  // can happen when a large value is converted to a floating point JavaScript.
-  // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
-  // use the JavaScript "number" type.  The behavior of the default option
-  // JS_NORMAL is implementation dependent.
-  //
-  // This option is an enum to permit additional types to be added, e.g.
-  // goog.math.Integer.
-  optional JSType jstype = 6 [default = JS_NORMAL];
-  enum JSType {
-    // Use the default type.
-    JS_NORMAL = 0;
-
-    // Use JavaScript strings.
-    JS_STRING = 1;
-
-    // Use JavaScript numbers.
-    JS_NUMBER = 2;
-  }
-
-  // Should this field be parsed lazily?  Lazy applies only to message-type
-  // fields.  It means that when the outer message is initially parsed, the
-  // inner message's contents will not be parsed but instead stored in encoded
-  // form.  The inner message will actually be parsed when it is first accessed.
-  //
-  // This is only a hint.  Implementations are free to choose whether to use
-  // eager or lazy parsing regardless of the value of this option.  However,
-  // setting this option true suggests that the protocol author believes that
-  // using lazy parsing on this field is worth the additional bookkeeping
-  // overhead typically needed to implement it.
-  //
-  // This option does not affect the public interface of any generated code;
-  // all method signatures remain the same.  Furthermore, thread-safety of the
-  // interface is not affected by this option; const methods remain safe to
-  // call from multiple threads concurrently, while non-const methods continue
-  // to require exclusive access.
-  //
-  //
-  // Note that implementations may choose not to check required fields within
-  // a lazy sub-message.  That is, calling IsInitialized() on the outer message
-  // may return true even if the inner message has missing required fields.
-  // This is necessary because otherwise the inner message would have to be
-  // parsed in order to perform the check, defeating the purpose of lazy
-  // parsing.  An implementation which chooses not to check required fields
-  // must be consistent about it.  That is, for any particular sub-message, the
-  // implementation must either *always* check its required fields, or *never*
-  // check its required fields, regardless of whether or not the message has
-  // been parsed.
-  optional bool lazy = 5 [default=false];
-
-  // Is this field deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for accessors, or it will be completely ignored; in the very least, this
-  // is a formalization for deprecating fields.
-  optional bool deprecated = 3 [default=false];
-
-  // For Google-internal migration only. Do not use.
-  optional bool weak = 10 [default=false];
-
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-
-  reserved 4;  // removed jtype
-}
-
-message OneofOptions {
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message EnumOptions {
-
-  // Set this option to true to allow mapping different tag names to the same
-  // value.
-  optional bool allow_alias = 2;
-
-  // Is this enum deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the enum, or it will be completely ignored; in the very least, this
-  // is a formalization for deprecating enums.
-  optional bool deprecated = 3 [default=false];
-
-  reserved 5;  // javanano_as_lite
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message EnumValueOptions {
-  // Is this enum value deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the enum value, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating enum values.
-  optional bool deprecated = 1 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message ServiceOptions {
-
-  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
-  //   framework.  We apologize for hoarding these numbers to ourselves, but
-  //   we were already using them long before we decided to release Protocol
-  //   Buffers.
-
-  // Is this service deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the service, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating services.
-  optional bool deprecated = 33 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message MethodOptions {
-
-  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
-  //   framework.  We apologize for hoarding these numbers to ourselves, but
-  //   we were already using them long before we decided to release Protocol
-  //   Buffers.
-
-  // Is this method deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the method, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating methods.
-  optional bool deprecated = 33 [default=false];
-
-  // Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
-  // or neither? HTTP based RPC implementation may choose GET verb for safe
-  // methods, and PUT verb for idempotent methods instead of the default POST.
-  enum IdempotencyLevel {
-    IDEMPOTENCY_UNKNOWN = 0;
-    NO_SIDE_EFFECTS     = 1; // implies idempotent
-    IDEMPOTENT          = 2; // idempotent, but may have side effects
-  }
-  optional IdempotencyLevel idempotency_level =
-      34 [default=IDEMPOTENCY_UNKNOWN];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-
-// A message representing a option the parser does not recognize. This only
-// appears in options protos created by the compiler::Parser class.
-// DescriptorPool resolves these when building Descriptor objects. Therefore,
-// options protos in descriptor objects (e.g. returned by Descriptor::options(),
-// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
-// in them.
-message UninterpretedOption {
-  // The name of the uninterpreted option.  Each string represents a segment in
-  // a dot-separated name.  is_extension is true iff a segment represents an
-  // extension (denoted with parentheses in options specs in .proto files).
-  // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
-  // "foo.(bar.baz).qux".
-  message NamePart {
-    required string name_part = 1;
-    required bool is_extension = 2;
-  }
-  repeated NamePart name = 2;
-
-  // The value of the uninterpreted option, in whatever type the tokenizer
-  // identified it as during parsing. Exactly one of these should be set.
-  optional string identifier_value = 3;
-  optional uint64 positive_int_value = 4;
-  optional int64 negative_int_value = 5;
-  optional double double_value = 6;
-  optional bytes string_value = 7;
-  optional string aggregate_value = 8;
-}
-
-// ===================================================================
-// Optional source code info
-
-// Encapsulates information about the original source file from which a
-// FileDescriptorProto was generated.
-message SourceCodeInfo {
-  // A Location identifies a piece of source code in a .proto file which
-  // corresponds to a particular definition.  This information is intended
-  // to be useful to IDEs, code indexers, documentation generators, and similar
-  // tools.
-  //
-  // For example, say we have a file like:
-  //   message Foo {
-  //     optional string foo = 1;
-  //   }
-  // Let's look at just the field definition:
-  //   optional string foo = 1;
-  //   ^       ^^     ^^  ^  ^^^
-  //   a       bc     de  f  ghi
-  // We have the following locations:
-  //   span   path               represents
-  //   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
-  //   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
-  //   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
-  //   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
-  //   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
-  //
-  // Notes:
-  // - A location may refer to a repeated field itself (i.e. not to any
-  //   particular index within it).  This is used whenever a set of elements are
-  //   logically enclosed in a single code segment.  For example, an entire
-  //   extend block (possibly containing multiple extension definitions) will
-  //   have an outer location whose path refers to the "extensions" repeated
-  //   field without an index.
-  // - Multiple locations may have the same path.  This happens when a single
-  //   logical declaration is spread out across multiple places.  The most
-  //   obvious example is the "extend" block again -- there may be multiple
-  //   extend blocks in the same scope, each of which will have the same path.
-  // - A location's span is not always a subset of its parent's span.  For
-  //   example, the "extendee" of an extension declaration appears at the
-  //   beginning of the "extend" block and is shared by all extensions within
-  //   the block.
-  // - Just because a location's span is a subset of some other location's span
-  //   does not mean that it is a descendent.  For example, a "group" defines
-  //   both a type and a field in a single declaration.  Thus, the locations
-  //   corresponding to the type and field and their components will overlap.
-  // - Code which tries to interpret locations should probably be designed to
-  //   ignore those that it doesn't understand, as more types of locations could
-  //   be recorded in the future.
-  repeated Location location = 1;
-  message Location {
-    // Identifies which part of the FileDescriptorProto was defined at this
-    // location.
-    //
-    // Each element is a field number or an index.  They form a path from
-    // the root FileDescriptorProto to the place where the definition.  For
-    // example, this path:
-    //   [ 4, 3, 2, 7, 1 ]
-    // refers to:
-    //   file.message_type(3)  // 4, 3
-    //       .field(7)         // 2, 7
-    //       .name()           // 1
-    // This is because FileDescriptorProto.message_type has field number 4:
-    //   repeated DescriptorProto message_type = 4;
-    // and DescriptorProto.field has field number 2:
-    //   repeated FieldDescriptorProto field = 2;
-    // and FieldDescriptorProto.name has field number 1:
-    //   optional string name = 1;
-    //
-    // Thus, the above path gives the location of a field name.  If we removed
-    // the last element:
-    //   [ 4, 3, 2, 7 ]
-    // this path refers to the whole field declaration (from the beginning
-    // of the label to the terminating semicolon).
-    repeated int32 path = 1 [packed=true];
-
-    // Always has exactly three or four elements: start line, start column,
-    // end line (optional, otherwise assumed same as start line), end column.
-    // These are packed into a single field for efficiency.  Note that line
-    // and column numbers are zero-based -- typically you will want to add
-    // 1 to each before displaying to a user.
-    repeated int32 span = 2 [packed=true];
-
-    // If this SourceCodeInfo represents a complete declaration, these are any
-    // comments appearing before and after the declaration which appear to be
-    // attached to the declaration.
-    //
-    // A series of line comments appearing on consecutive lines, with no other
-    // tokens appearing on those lines, will be treated as a single comment.
-    //
-    // leading_detached_comments will keep paragraphs of comments that appear
-    // before (but not connected to) the current element. Each paragraph,
-    // separated by empty lines, will be one comment element in the repeated
-    // field.
-    //
-    // Only the comment content is provided; comment markers (e.g. //) are
-    // stripped out.  For block comments, leading whitespace and an asterisk
-    // will be stripped from the beginning of each line other than the first.
-    // Newlines are included in the output.
-    //
-    // Examples:
-    //
-    //   optional int32 foo = 1;  // Comment attached to foo.
-    //   // Comment attached to bar.
-    //   optional int32 bar = 2;
-    //
-    //   optional string baz = 3;
-    //   // Comment attached to baz.
-    //   // Another line attached to baz.
-    //
-    //   // Comment attached to qux.
-    //   //
-    //   // Another line attached to qux.
-    //   optional double qux = 4;
-    //
-    //   // Detached comment for corge. This is not leading or trailing comments
-    //   // to qux or corge because there are blank lines separating it from
-    //   // both.
-    //
-    //   // Detached comment for corge paragraph 2.
-    //
-    //   optional string corge = 5;
-    //   /* Block comment attached
-    //    * to corge.  Leading asterisks
-    //    * will be removed. */
-    //   /* Block comment attached to
-    //    * grault. */
-    //   optional int32 grault = 6;
-    //
-    //   // ignored detached comments.
-    optional string leading_comments = 3;
-    optional string trailing_comments = 4;
-    repeated string leading_detached_comments = 6;
-  }
-}
-
-// Describes the relationship between generated code and its original source
-// file. A GeneratedCodeInfo message is associated with only one generated
-// source file, but may contain references to different source .proto files.
-message GeneratedCodeInfo {
-  // An Annotation connects some span of text in generated code to an element
-  // of its generating .proto file.
-  repeated Annotation annotation = 1;
-  message Annotation {
-    // Identifies the element in the original source .proto file. This field
-    // is formatted the same as SourceCodeInfo.Location.path.
-    repeated int32 path = 1 [packed=true];
-
-    // Identifies the filesystem path to the original source .proto.
-    optional string source_file = 2;
-
-    // Identifies the starting offset in bytes in the generated code
-    // that relates to the identified object.
-    optional int32 begin = 3;
-
-    // Identifies the ending offset in bytes in the generated code that
-    // relates to the identified offset. The end offset should be one past
-    // the last relevant byte (so the length of the text = end - begin).
-    optional int32 end = 4;
-  }
-}
diff --git a/vendor/github.com/gorilla/websocket/.gitignore b/vendor/github.com/gorilla/websocket/.gitignore
index 00268614f04..ac710204fa1 100644
--- a/vendor/github.com/gorilla/websocket/.gitignore
+++ b/vendor/github.com/gorilla/websocket/.gitignore
@@ -20,3 +20,6 @@ _cgo_export.*
 _testmain.go
 
 *.exe
+
+.idea/
+*.iml
\ No newline at end of file
diff --git a/vendor/github.com/gorilla/websocket/.travis.yml b/vendor/github.com/gorilla/websocket/.travis.yml
index 8687342e9d4..9f233f983d6 100644
--- a/vendor/github.com/gorilla/websocket/.travis.yml
+++ b/vendor/github.com/gorilla/websocket/.travis.yml
@@ -1,6 +1,20 @@
 language: go
+sudo: false
 
-go:
-  - 1.1
-  - 1.2
-  - tip
+matrix:
+  include:
+    - go: 1.4
+    - go: 1.5
+    - go: 1.6
+    - go: 1.7
+    - go: 1.8
+    - go: 1.9
+    - go: tip
+  allow_failures:
+    - go: tip
+
+script:
+  - go get -t -v ./...
+  - diff -u <(echo -n) <(gofmt -d .)
+  - go vet $(go list ./... | grep -v /vendor/)
+  - go test -v -race ./...
diff --git a/vendor/github.com/gorilla/websocket/BUILD b/vendor/github.com/gorilla/websocket/BUILD
index 8c2f525d716..b6373362226 100644
--- a/vendor/github.com/gorilla/websocket/BUILD
+++ b/vendor/github.com/gorilla/websocket/BUILD
@@ -4,9 +4,16 @@ go_library(
     name = "go_default_library",
     srcs = [
         "client.go",
+        "client_clone.go",
+        "client_clone_legacy.go",
+        "compression.go",
         "conn.go",
+        "conn_read.go",
+        "conn_read_legacy.go",
         "doc.go",
         "json.go",
+        "mask.go",
+        "prepared.go",
         "server.go",
         "util.go",
     ],
diff --git a/vendor/github.com/gorilla/websocket/README.md b/vendor/github.com/gorilla/websocket/README.md
index 9ad75a0f5e9..33c3d2be3e3 100644
--- a/vendor/github.com/gorilla/websocket/README.md
+++ b/vendor/github.com/gorilla/websocket/README.md
@@ -3,10 +3,15 @@
 Gorilla WebSocket is a [Go](http://golang.org/) implementation of the
 [WebSocket](http://www.rfc-editor.org/rfc/rfc6455.txt) protocol.
 
+[![Build Status](https://travis-ci.org/gorilla/websocket.svg?branch=master)](https://travis-ci.org/gorilla/websocket)
+[![GoDoc](https://godoc.org/github.com/gorilla/websocket?status.svg)](https://godoc.org/github.com/gorilla/websocket)
+
 ### Documentation
 
 * [API Reference](http://godoc.org/github.com/gorilla/websocket)
 * [Chat example](https://github.com/gorilla/websocket/tree/master/examples/chat)
+* [Command example](https://github.com/gorilla/websocket/tree/master/examples/command)
+* [Client and server example](https://github.com/gorilla/websocket/tree/master/examples/echo)
 * [File watch example](https://github.com/gorilla/websocket/tree/master/examples/filewatch)
 
 ### Status
@@ -41,7 +46,7 @@ subdirectory](https://github.com/gorilla/websocket/tree/master/examples/autobahn
 <tr><td>Send <a href="https://tools.ietf.org/html/rfc6455#section-5.5.2">pings</a> and receive <a href="https://tools.ietf.org/html/rfc6455#section-5.5.3">pongs</a></td><td><a href="http://godoc.org/github.com/gorilla/websocket#hdr-Control_Messages">Yes</a></td><td>No</td></tr>
 <tr><td>Get the <a href="https://tools.ietf.org/html/rfc6455#section-5.6">type</a> of a received data message</td><td>Yes</td><td>Yes, see note 2</td></tr>
 <tr><td colspan="3">Other Features</tr></td>
-<tr><td>Limit size of received message</td><td><a href="http://godoc.org/github.com/gorilla/websocket#Conn.SetReadLimit">Yes</a></td><td><a href="https://code.google.com/p/go/issues/detail?id=5082">No</a></td></tr>
+<tr><td><a href="https://tools.ietf.org/html/rfc7692">Compression Extensions</a></td><td>Experimental</td><td>No</td></tr>
 <tr><td>Read message using io.Reader</td><td><a href="http://godoc.org/github.com/gorilla/websocket#Conn.NextReader">Yes</a></td><td>No, see note 3</td></tr>
 <tr><td>Write message using io.WriteCloser</td><td><a href="http://godoc.org/github.com/gorilla/websocket#Conn.NextWriter">Yes</a></td><td>No, see note 3</td></tr>
 </table>
diff --git a/vendor/github.com/gorilla/websocket/client.go b/vendor/github.com/gorilla/websocket/client.go
index 93db8ddc320..43a87c753bf 100644
--- a/vendor/github.com/gorilla/websocket/client.go
+++ b/vendor/github.com/gorilla/websocket/client.go
@@ -5,8 +5,10 @@
 package websocket
 
 import (
+	"bufio"
 	"bytes"
 	"crypto/tls"
+	"encoding/base64"
 	"errors"
 	"io"
 	"io/ioutil"
@@ -21,6 +23,8 @@ import (
 // invalid.
 var ErrBadHandshake = errors.New("websocket: bad handshake")
 
+var errInvalidCompression = errors.New("websocket: invalid compression negotiation")
+
 // NewClient creates a new client connection using the given net connection.
 // The URL u specifies the host and request URI. Use requestHeader to specify
 // the origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies
@@ -30,50 +34,17 @@ var ErrBadHandshake = errors.New("websocket: bad handshake")
 // If the WebSocket handshake fails, ErrBadHandshake is returned along with a
 // non-nil *http.Response so that callers can handle redirects, authentication,
 // etc.
+//
+// Deprecated: Use Dialer instead.
 func NewClient(netConn net.Conn, u *url.URL, requestHeader http.Header, readBufSize, writeBufSize int) (c *Conn, response *http.Response, err error) {
-	challengeKey, err := generateChallengeKey()
-	if err != nil {
-		return nil, nil, err
+	d := Dialer{
+		ReadBufferSize:  readBufSize,
+		WriteBufferSize: writeBufSize,
+		NetDial: func(net, addr string) (net.Conn, error) {
+			return netConn, nil
+		},
 	}
-	acceptKey := computeAcceptKey(challengeKey)
-
-	c = newConn(netConn, false, readBufSize, writeBufSize)
-	p := c.writeBuf[:0]
-	p = append(p, "GET "...)
-	p = append(p, u.RequestURI()...)
-	p = append(p, " HTTP/1.1\r\nHost: "...)
-	p = append(p, u.Host...)
-	// "Upgrade" is capitalized for servers that do not use case insensitive
-	// comparisons on header tokens.
-	p = append(p, "\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: "...)
-	p = append(p, challengeKey...)
-	p = append(p, "\r\n"...)
-	for k, vs := range requestHeader {
-		for _, v := range vs {
-			p = append(p, k...)
-			p = append(p, ": "...)
-			p = append(p, v...)
-			p = append(p, "\r\n"...)
-		}
-	}
-	p = append(p, "\r\n"...)
-
-	if _, err := netConn.Write(p); err != nil {
-		return nil, nil, err
-	}
-
-	resp, err := http.ReadResponse(c.br, &http.Request{Method: "GET", URL: u})
-	if err != nil {
-		return nil, nil, err
-	}
-	if resp.StatusCode != 101 ||
-		!strings.EqualFold(resp.Header.Get("Upgrade"), "websocket") ||
-		!strings.EqualFold(resp.Header.Get("Connection"), "upgrade") ||
-		resp.Header.Get("Sec-Websocket-Accept") != acceptKey {
-		return nil, resp, ErrBadHandshake
-	}
-	c.subprotocol = resp.Header.Get("Sec-Websocket-Protocol")
-	return c, resp, nil
+	return d.Dial(u.String(), requestHeader)
 }
 
 // A Dialer contains options for connecting to WebSocket server.
@@ -82,6 +53,12 @@ type Dialer struct {
 	// NetDial is nil, net.Dial is used.
 	NetDial func(network, addr string) (net.Conn, error)
 
+	// Proxy specifies a function to return a proxy for a given
+	// Request. If the function returns a non-nil error, the
+	// request is aborted with the provided error.
+	// If Proxy is nil or returns a nil *URL, no proxy is used.
+	Proxy func(*http.Request) (*url.URL, error)
+
 	// TLSClientConfig specifies the TLS configuration to use with tls.Client.
 	// If nil, the default configuration is used.
 	TLSClientConfig *tls.Config
@@ -89,28 +66,37 @@ type Dialer struct {
 	// HandshakeTimeout specifies the duration for the handshake to complete.
 	HandshakeTimeout time.Duration
 
-	// Input and output buffer sizes. If the buffer size is zero, then a
-	// default value of 4096 is used.
+	// ReadBufferSize and WriteBufferSize specify I/O buffer sizes. If a buffer
+	// size is zero, then a useful default size is used. The I/O buffer sizes
+	// do not limit the size of the messages that can be sent or received.
 	ReadBufferSize, WriteBufferSize int
 
 	// Subprotocols specifies the client's requested subprotocols.
 	Subprotocols []string
+
+	// EnableCompression specifies if the client should attempt to negotiate
+	// per message compression (RFC 7692). Setting this value to true does not
+	// guarantee that compression will be supported. Currently only "no context
+	// takeover" modes are supported.
+	EnableCompression bool
+
+	// Jar specifies the cookie jar.
+	// If Jar is nil, cookies are not sent in requests and ignored
+	// in responses.
+	Jar http.CookieJar
 }
 
 var errMalformedURL = errors.New("malformed ws or wss URL")
 
-// parseURL parses the URL. The url.Parse function is not used here because
-// url.Parse mangles the path.
+// parseURL parses the URL.
+//
+// This function is a replacement for the standard library url.Parse function.
+// In Go 1.4 and earlier, url.Parse loses information from the path.
 func parseURL(s string) (*url.URL, error) {
 	// From the RFC:
 	//
 	// ws-URI = "ws:" "//" host [ ":" port ] path [ "?" query ]
 	// wss-URI = "wss:" "//" host [ ":" port ] path [ "?" query ]
-	//
-	// We don't use the net/url parser here because the dialer interface does
-	// not provide a way for applications to work around percent deocding in
-	// the net/url parser.
-
 	var u url.URL
 	switch {
 	case strings.HasPrefix(s, "ws://"):
@@ -123,15 +109,23 @@ func parseURL(s string) (*url.URL, error) {
 		return nil, errMalformedURL
 	}
 
-	u.Host = s
-	u.Opaque = "/"
-	if i := strings.Index(s, "/"); i >= 0 {
-		u.Host = s[:i]
-		u.Opaque = s[i:]
+	if i := strings.Index(s, "?"); i >= 0 {
+		u.RawQuery = s[i+1:]
+		s = s[:i]
 	}
 
+	if i := strings.Index(s, "/"); i >= 0 {
+		u.Opaque = s[i:]
+		s = s[:i]
+	} else {
+		u.Opaque = "/"
+	}
+
+	u.Host = s
+
 	if strings.Contains(u.Host, "@") {
-		// WebSocket URIs do not contain user information.
+		// Don't bother parsing user information because user information is
+		// not allowed in websocket URIs.
 		return nil, errMalformedURL
 	}
 
@@ -144,9 +138,12 @@ func hostPortNoPort(u *url.URL) (hostPort, hostNoPort string) {
 	if i := strings.LastIndex(u.Host, ":"); i > strings.LastIndex(u.Host, "]") {
 		hostNoPort = hostNoPort[:i]
 	} else {
-		if u.Scheme == "wss" {
+		switch u.Scheme {
+		case "wss":
 			hostPort += ":443"
-		} else {
+		case "https":
+			hostPort += ":443"
+		default:
 			hostPort += ":80"
 		}
 	}
@@ -154,7 +151,9 @@ func hostPortNoPort(u *url.URL) (hostPort, hostNoPort string) {
 }
 
 // DefaultDialer is a dialer with all fields set to the default zero values.
-var DefaultDialer *Dialer
+var DefaultDialer = &Dialer{
+	Proxy: http.ProxyFromEnvironment,
+}
 
 // Dial creates a new client connection. Use requestHeader to specify the
 // origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies (Cookie).
@@ -166,15 +165,103 @@ var DefaultDialer *Dialer
 // etcetera. The response body may not contain the entire response and does not
 // need to be closed by the application.
 func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Response, error) {
+
+	if d == nil {
+		d = &Dialer{
+			Proxy: http.ProxyFromEnvironment,
+		}
+	}
+
+	challengeKey, err := generateChallengeKey()
+	if err != nil {
+		return nil, nil, err
+	}
+
 	u, err := parseURL(urlStr)
 	if err != nil {
 		return nil, nil, err
 	}
 
+	switch u.Scheme {
+	case "ws":
+		u.Scheme = "http"
+	case "wss":
+		u.Scheme = "https"
+	default:
+		return nil, nil, errMalformedURL
+	}
+
+	if u.User != nil {
+		// User name and password are not allowed in websocket URIs.
+		return nil, nil, errMalformedURL
+	}
+
+	req := &http.Request{
+		Method:     "GET",
+		URL:        u,
+		Proto:      "HTTP/1.1",
+		ProtoMajor: 1,
+		ProtoMinor: 1,
+		Header:     make(http.Header),
+		Host:       u.Host,
+	}
+
+	// Set the cookies present in the cookie jar of the dialer
+	if d.Jar != nil {
+		for _, cookie := range d.Jar.Cookies(u) {
+			req.AddCookie(cookie)
+		}
+	}
+
+	// Set the request headers using the capitalization for names and values in
+	// RFC examples. Although the capitalization shouldn't matter, there are
+	// servers that depend on it. The Header.Set method is not used because the
+	// method canonicalizes the header names.
+	req.Header["Upgrade"] = []string{"websocket"}
+	req.Header["Connection"] = []string{"Upgrade"}
+	req.Header["Sec-WebSocket-Key"] = []string{challengeKey}
+	req.Header["Sec-WebSocket-Version"] = []string{"13"}
+	if len(d.Subprotocols) > 0 {
+		req.Header["Sec-WebSocket-Protocol"] = []string{strings.Join(d.Subprotocols, ", ")}
+	}
+	for k, vs := range requestHeader {
+		switch {
+		case k == "Host":
+			if len(vs) > 0 {
+				req.Host = vs[0]
+			}
+		case k == "Upgrade" ||
+			k == "Connection" ||
+			k == "Sec-Websocket-Key" ||
+			k == "Sec-Websocket-Version" ||
+			k == "Sec-Websocket-Extensions" ||
+			(k == "Sec-Websocket-Protocol" && len(d.Subprotocols) > 0):
+			return nil, nil, errors.New("websocket: duplicate header not allowed: " + k)
+		default:
+			req.Header[k] = vs
+		}
+	}
+
+	if d.EnableCompression {
+		req.Header.Set("Sec-Websocket-Extensions", "permessage-deflate; server_no_context_takeover; client_no_context_takeover")
+	}
+
 	hostPort, hostNoPort := hostPortNoPort(u)
 
-	if d == nil {
-		d = &Dialer{}
+	var proxyURL *url.URL
+	// Check wether the proxy method has been configured
+	if d.Proxy != nil {
+		proxyURL, err = d.Proxy(req)
+	}
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var targetHostPort string
+	if proxyURL != nil {
+		targetHostPort, _ = hostPortNoPort(proxyURL)
+	} else {
+		targetHostPort = hostPort
 	}
 
 	var deadline time.Time
@@ -188,7 +275,7 @@ func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Re
 		netDial = netDialer.Dial
 	}
 
-	netConn, err := netDial("tcp", hostPort)
+	netConn, err := netDial("tcp", targetHostPort)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -203,13 +290,41 @@ func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Re
 		return nil, nil, err
 	}
 
-	if u.Scheme == "wss" {
-		cfg := d.TLSClientConfig
-		if cfg == nil {
-			cfg = &tls.Config{ServerName: hostNoPort}
-		} else if cfg.ServerName == "" {
-			shallowCopy := *cfg
-			cfg = &shallowCopy
+	if proxyURL != nil {
+		connectHeader := make(http.Header)
+		if user := proxyURL.User; user != nil {
+			proxyUser := user.Username()
+			if proxyPassword, passwordSet := user.Password(); passwordSet {
+				credential := base64.StdEncoding.EncodeToString([]byte(proxyUser + ":" + proxyPassword))
+				connectHeader.Set("Proxy-Authorization", "Basic "+credential)
+			}
+		}
+		connectReq := &http.Request{
+			Method: "CONNECT",
+			URL:    &url.URL{Opaque: hostPort},
+			Host:   hostPort,
+			Header: connectHeader,
+		}
+
+		connectReq.Write(netConn)
+
+		// Read response.
+		// Okay to use and discard buffered reader here, because
+		// TLS server will not speak until spoken to.
+		br := bufio.NewReader(netConn)
+		resp, err := http.ReadResponse(br, connectReq)
+		if err != nil {
+			return nil, nil, err
+		}
+		if resp.StatusCode != 200 {
+			f := strings.SplitN(resp.Status, " ", 2)
+			return nil, nil, errors.New(f[1])
+		}
+	}
+
+	if u.Scheme == "https" {
+		cfg := cloneTLSConfig(d.TLSClientConfig)
+		if cfg.ServerName == "" {
 			cfg.ServerName = hostNoPort
 		}
 		tlsConn := tls.Client(netConn, cfg)
@@ -224,45 +339,53 @@ func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Re
 		}
 	}
 
-	if len(d.Subprotocols) > 0 {
-		h := http.Header{}
-		for k, v := range requestHeader {
-			h[k] = v
-		}
-		h.Set("Sec-Websocket-Protocol", strings.Join(d.Subprotocols, ", "))
-		requestHeader = h
+	conn := newConn(netConn, false, d.ReadBufferSize, d.WriteBufferSize)
+
+	if err := req.Write(netConn); err != nil {
+		return nil, nil, err
 	}
 
-	if len(requestHeader["Host"]) > 0 {
-		// This can be used to supply a Host: header which is different from
-		// the dial address.
-		u.Host = requestHeader.Get("Host")
-
-		// Drop "Host" header
-		h := http.Header{}
-		for k, v := range requestHeader {
-			if k == "Host" {
-				continue
-			}
-			h[k] = v
-		}
-		requestHeader = h
-	}
-
-	conn, resp, err := NewClient(netConn, u, requestHeader, d.ReadBufferSize, d.WriteBufferSize)
-
+	resp, err := http.ReadResponse(conn.br, req)
 	if err != nil {
-		if err == ErrBadHandshake {
-			// Before closing the network connection on return from this
-			// function, slurp up some of the response to aid application
-			// debugging.
-			buf := make([]byte, 1024)
-			n, _ := io.ReadFull(resp.Body, buf)
-			resp.Body = ioutil.NopCloser(bytes.NewReader(buf[:n]))
-		}
-		return nil, resp, err
+		return nil, nil, err
 	}
 
+	if d.Jar != nil {
+		if rc := resp.Cookies(); len(rc) > 0 {
+			d.Jar.SetCookies(u, rc)
+		}
+	}
+
+	if resp.StatusCode != 101 ||
+		!strings.EqualFold(resp.Header.Get("Upgrade"), "websocket") ||
+		!strings.EqualFold(resp.Header.Get("Connection"), "upgrade") ||
+		resp.Header.Get("Sec-Websocket-Accept") != computeAcceptKey(challengeKey) {
+		// Before closing the network connection on return from this
+		// function, slurp up some of the response to aid application
+		// debugging.
+		buf := make([]byte, 1024)
+		n, _ := io.ReadFull(resp.Body, buf)
+		resp.Body = ioutil.NopCloser(bytes.NewReader(buf[:n]))
+		return nil, resp, ErrBadHandshake
+	}
+
+	for _, ext := range parseExtensions(resp.Header) {
+		if ext[""] != "permessage-deflate" {
+			continue
+		}
+		_, snct := ext["server_no_context_takeover"]
+		_, cnct := ext["client_no_context_takeover"]
+		if !snct || !cnct {
+			return nil, resp, errInvalidCompression
+		}
+		conn.newCompressionWriter = compressNoContextTakeover
+		conn.newDecompressionReader = decompressNoContextTakeover
+		break
+	}
+
+	resp.Body = ioutil.NopCloser(bytes.NewReader([]byte{}))
+	conn.subprotocol = resp.Header.Get("Sec-Websocket-Protocol")
+
 	netConn.SetDeadline(time.Time{})
 	netConn = nil // to avoid close in defer.
 	return conn, resp, nil
diff --git a/vendor/github.com/gorilla/websocket/client_clone.go b/vendor/github.com/gorilla/websocket/client_clone.go
new file mode 100644
index 00000000000..4f0d943723a
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/client_clone.go
@@ -0,0 +1,16 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.8
+
+package websocket
+
+import "crypto/tls"
+
+func cloneTLSConfig(cfg *tls.Config) *tls.Config {
+	if cfg == nil {
+		return &tls.Config{}
+	}
+	return cfg.Clone()
+}
diff --git a/vendor/github.com/gorilla/websocket/client_clone_legacy.go b/vendor/github.com/gorilla/websocket/client_clone_legacy.go
new file mode 100644
index 00000000000..babb007fb41
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/client_clone_legacy.go
@@ -0,0 +1,38 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.8
+
+package websocket
+
+import "crypto/tls"
+
+// cloneTLSConfig clones all public fields except the fields
+// SessionTicketsDisabled and SessionTicketKey. This avoids copying the
+// sync.Mutex in the sync.Once and makes it safe to call cloneTLSConfig on a
+// config in active use.
+func cloneTLSConfig(cfg *tls.Config) *tls.Config {
+	if cfg == nil {
+		return &tls.Config{}
+	}
+	return &tls.Config{
+		Rand:                     cfg.Rand,
+		Time:                     cfg.Time,
+		Certificates:             cfg.Certificates,
+		NameToCertificate:        cfg.NameToCertificate,
+		GetCertificate:           cfg.GetCertificate,
+		RootCAs:                  cfg.RootCAs,
+		NextProtos:               cfg.NextProtos,
+		ServerName:               cfg.ServerName,
+		ClientAuth:               cfg.ClientAuth,
+		ClientCAs:                cfg.ClientCAs,
+		InsecureSkipVerify:       cfg.InsecureSkipVerify,
+		CipherSuites:             cfg.CipherSuites,
+		PreferServerCipherSuites: cfg.PreferServerCipherSuites,
+		ClientSessionCache:       cfg.ClientSessionCache,
+		MinVersion:               cfg.MinVersion,
+		MaxVersion:               cfg.MaxVersion,
+		CurvePreferences:         cfg.CurvePreferences,
+	}
+}
diff --git a/vendor/github.com/gorilla/websocket/compression.go b/vendor/github.com/gorilla/websocket/compression.go
new file mode 100644
index 00000000000..813ffb1e843
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/compression.go
@@ -0,0 +1,148 @@
+// Copyright 2017 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+	"compress/flate"
+	"errors"
+	"io"
+	"strings"
+	"sync"
+)
+
+const (
+	minCompressionLevel     = -2 // flate.HuffmanOnly not defined in Go < 1.6
+	maxCompressionLevel     = flate.BestCompression
+	defaultCompressionLevel = 1
+)
+
+var (
+	flateWriterPools [maxCompressionLevel - minCompressionLevel + 1]sync.Pool
+	flateReaderPool  = sync.Pool{New: func() interface{} {
+		return flate.NewReader(nil)
+	}}
+)
+
+func decompressNoContextTakeover(r io.Reader) io.ReadCloser {
+	const tail =
+	// Add four bytes as specified in RFC
+	"\x00\x00\xff\xff" +
+		// Add final block to squelch unexpected EOF error from flate reader.
+		"\x01\x00\x00\xff\xff"
+
+	fr, _ := flateReaderPool.Get().(io.ReadCloser)
+	fr.(flate.Resetter).Reset(io.MultiReader(r, strings.NewReader(tail)), nil)
+	return &flateReadWrapper{fr}
+}
+
+func isValidCompressionLevel(level int) bool {
+	return minCompressionLevel <= level && level <= maxCompressionLevel
+}
+
+func compressNoContextTakeover(w io.WriteCloser, level int) io.WriteCloser {
+	p := &flateWriterPools[level-minCompressionLevel]
+	tw := &truncWriter{w: w}
+	fw, _ := p.Get().(*flate.Writer)
+	if fw == nil {
+		fw, _ = flate.NewWriter(tw, level)
+	} else {
+		fw.Reset(tw)
+	}
+	return &flateWriteWrapper{fw: fw, tw: tw, p: p}
+}
+
+// truncWriter is an io.Writer that writes all but the last four bytes of the
+// stream to another io.Writer.
+type truncWriter struct {
+	w io.WriteCloser
+	n int
+	p [4]byte
+}
+
+func (w *truncWriter) Write(p []byte) (int, error) {
+	n := 0
+
+	// fill buffer first for simplicity.
+	if w.n < len(w.p) {
+		n = copy(w.p[w.n:], p)
+		p = p[n:]
+		w.n += n
+		if len(p) == 0 {
+			return n, nil
+		}
+	}
+
+	m := len(p)
+	if m > len(w.p) {
+		m = len(w.p)
+	}
+
+	if nn, err := w.w.Write(w.p[:m]); err != nil {
+		return n + nn, err
+	}
+
+	copy(w.p[:], w.p[m:])
+	copy(w.p[len(w.p)-m:], p[len(p)-m:])
+	nn, err := w.w.Write(p[:len(p)-m])
+	return n + nn, err
+}
+
+type flateWriteWrapper struct {
+	fw *flate.Writer
+	tw *truncWriter
+	p  *sync.Pool
+}
+
+func (w *flateWriteWrapper) Write(p []byte) (int, error) {
+	if w.fw == nil {
+		return 0, errWriteClosed
+	}
+	return w.fw.Write(p)
+}
+
+func (w *flateWriteWrapper) Close() error {
+	if w.fw == nil {
+		return errWriteClosed
+	}
+	err1 := w.fw.Flush()
+	w.p.Put(w.fw)
+	w.fw = nil
+	if w.tw.p != [4]byte{0, 0, 0xff, 0xff} {
+		return errors.New("websocket: internal error, unexpected bytes at end of flate stream")
+	}
+	err2 := w.tw.w.Close()
+	if err1 != nil {
+		return err1
+	}
+	return err2
+}
+
+type flateReadWrapper struct {
+	fr io.ReadCloser
+}
+
+func (r *flateReadWrapper) Read(p []byte) (int, error) {
+	if r.fr == nil {
+		return 0, io.ErrClosedPipe
+	}
+	n, err := r.fr.Read(p)
+	if err == io.EOF {
+		// Preemptively place the reader back in the pool. This helps with
+		// scenarios where the application does not call NextReader() soon after
+		// this final read.
+		r.Close()
+	}
+	return n, err
+}
+
+func (r *flateReadWrapper) Close() error {
+	if r.fr == nil {
+		return io.ErrClosedPipe
+	}
+	err := r.fr.Close()
+	flateReaderPool.Put(r.fr)
+	r.fr = nil
+	return err
+}
diff --git a/vendor/github.com/gorilla/websocket/conn.go b/vendor/github.com/gorilla/websocket/conn.go
index e719f1ce63e..97e1dbacb12 100644
--- a/vendor/github.com/gorilla/websocket/conn.go
+++ b/vendor/github.com/gorilla/websocket/conn.go
@@ -13,15 +13,25 @@ import (
 	"math/rand"
 	"net"
 	"strconv"
+	"sync"
 	"time"
+	"unicode/utf8"
 )
 
 const (
+	// Frame header byte 0 bits from Section 5.2 of RFC 6455
+	finalBit = 1 << 7
+	rsv1Bit  = 1 << 6
+	rsv2Bit  = 1 << 5
+	rsv3Bit  = 1 << 4
+
+	// Frame header byte 1 bits from Section 5.2 of RFC 6455
+	maskBit = 1 << 7
+
 	maxFrameHeaderSize         = 2 + 8 + 4 // Fixed header + length + mask
 	maxControlFramePayloadSize = 125
-	finalBit                   = 1 << 7
-	maskBit                    = 1 << 7
-	writeWait                  = time.Second
+
+	writeWait = time.Second
 
 	defaultReadBufferSize  = 4096
 	defaultWriteBufferSize = 4096
@@ -43,6 +53,8 @@ const (
 	CloseMessageTooBig           = 1009
 	CloseMandatoryExtension      = 1010
 	CloseInternalServerErr       = 1011
+	CloseServiceRestart          = 1012
+	CloseTryAgainLater           = 1013
 	CloseTLSHandshake            = 1015
 )
 
@@ -88,24 +100,92 @@ func (e *netError) Error() string   { return e.msg }
 func (e *netError) Temporary() bool { return e.temporary }
 func (e *netError) Timeout() bool   { return e.timeout }
 
-// closeError represents close frame.
-type closeError struct {
-	code int
-	text string
+// CloseError represents close frame.
+type CloseError struct {
+
+	// Code is defined in RFC 6455, section 11.7.
+	Code int
+
+	// Text is the optional text payload.
+	Text string
 }
 
-func (e *closeError) Error() string {
-	return "websocket: close " + strconv.Itoa(e.code) + " " + e.text
+func (e *CloseError) Error() string {
+	s := []byte("websocket: close ")
+	s = strconv.AppendInt(s, int64(e.Code), 10)
+	switch e.Code {
+	case CloseNormalClosure:
+		s = append(s, " (normal)"...)
+	case CloseGoingAway:
+		s = append(s, " (going away)"...)
+	case CloseProtocolError:
+		s = append(s, " (protocol error)"...)
+	case CloseUnsupportedData:
+		s = append(s, " (unsupported data)"...)
+	case CloseNoStatusReceived:
+		s = append(s, " (no status)"...)
+	case CloseAbnormalClosure:
+		s = append(s, " (abnormal closure)"...)
+	case CloseInvalidFramePayloadData:
+		s = append(s, " (invalid payload data)"...)
+	case ClosePolicyViolation:
+		s = append(s, " (policy violation)"...)
+	case CloseMessageTooBig:
+		s = append(s, " (message too big)"...)
+	case CloseMandatoryExtension:
+		s = append(s, " (mandatory extension missing)"...)
+	case CloseInternalServerErr:
+		s = append(s, " (internal server error)"...)
+	case CloseTLSHandshake:
+		s = append(s, " (TLS handshake error)"...)
+	}
+	if e.Text != "" {
+		s = append(s, ": "...)
+		s = append(s, e.Text...)
+	}
+	return string(s)
+}
+
+// IsCloseError returns boolean indicating whether the error is a *CloseError
+// with one of the specified codes.
+func IsCloseError(err error, codes ...int) bool {
+	if e, ok := err.(*CloseError); ok {
+		for _, code := range codes {
+			if e.Code == code {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// IsUnexpectedCloseError returns boolean indicating whether the error is a
+// *CloseError with a code not in the list of expected codes.
+func IsUnexpectedCloseError(err error, expectedCodes ...int) bool {
+	if e, ok := err.(*CloseError); ok {
+		for _, code := range expectedCodes {
+			if e.Code == code {
+				return false
+			}
+		}
+		return true
+	}
+	return false
 }
 
 var (
-	errWriteTimeout        = &netError{msg: "websocket: write timeout", timeout: true}
-	errUnexpectedEOF       = &closeError{code: CloseAbnormalClosure, text: io.ErrUnexpectedEOF.Error()}
+	errWriteTimeout        = &netError{msg: "websocket: write timeout", timeout: true, temporary: true}
+	errUnexpectedEOF       = &CloseError{Code: CloseAbnormalClosure, Text: io.ErrUnexpectedEOF.Error()}
 	errBadWriteOpCode      = errors.New("websocket: bad write message type")
 	errWriteClosed         = errors.New("websocket: write closed")
 	errInvalidControlFrame = errors.New("websocket: invalid control frame")
 )
 
+func newMaskKey() [4]byte {
+	n := rand.Uint32()
+	return [4]byte{byte(n), byte(n >> 8), byte(n >> 16), byte(n >> 24)}
+}
+
 func hideTempErr(err error) error {
 	if e, ok := err.(net.Error); ok && e.Temporary() {
 		err = &netError{msg: e.Error(), timeout: e.Timeout()}
@@ -121,72 +201,138 @@ func isData(frameType int) bool {
 	return frameType == TextMessage || frameType == BinaryMessage
 }
 
-func maskBytes(key [4]byte, pos int, b []byte) int {
-	for i := range b {
-		b[i] ^= key[pos&3]
-		pos++
-	}
-	return pos & 3
+var validReceivedCloseCodes = map[int]bool{
+	// see http://www.iana.org/assignments/websocket/websocket.xhtml#close-code-number
+
+	CloseNormalClosure:           true,
+	CloseGoingAway:               true,
+	CloseProtocolError:           true,
+	CloseUnsupportedData:         true,
+	CloseNoStatusReceived:        false,
+	CloseAbnormalClosure:         false,
+	CloseInvalidFramePayloadData: true,
+	ClosePolicyViolation:         true,
+	CloseMessageTooBig:           true,
+	CloseMandatoryExtension:      true,
+	CloseInternalServerErr:       true,
+	CloseServiceRestart:          true,
+	CloseTryAgainLater:           true,
+	CloseTLSHandshake:            false,
 }
 
-func newMaskKey() [4]byte {
-	n := rand.Uint32()
-	return [4]byte{byte(n), byte(n >> 8), byte(n >> 16), byte(n >> 24)}
+func isValidReceivedCloseCode(code int) bool {
+	return validReceivedCloseCodes[code] || (code >= 3000 && code <= 4999)
 }
 
-// Conn represents a WebSocket connection.
+// The Conn type represents a WebSocket connection.
 type Conn struct {
 	conn        net.Conn
 	isServer    bool
 	subprotocol string
 
 	// Write fields
-	mu        chan bool // used as mutex to protect write to conn and closeSent
-	closeSent bool      // true if close message was sent
+	mu            chan bool // used as mutex to protect write to conn
+	writeBuf      []byte    // frame is constructed in this buffer.
+	writeDeadline time.Time
+	writer        io.WriteCloser // the current writer returned to the application
+	isWriting     bool           // for best-effort concurrent write detection
 
-	// Message writer fields.
-	writeErr       error
-	writeBuf       []byte // frame is constructed in this buffer.
-	writePos       int    // end of data in writeBuf.
-	writeFrameType int    // type of the current frame.
-	writeSeq       int    // incremented to invalidate message writers.
-	writeDeadline  time.Time
+	writeErrMu sync.Mutex
+	writeErr   error
+
+	enableWriteCompression bool
+	compressionLevel       int
+	newCompressionWriter   func(io.WriteCloser, int) io.WriteCloser
 
 	// Read fields
+	reader        io.ReadCloser // the current reader returned to the application
 	readErr       error
 	br            *bufio.Reader
 	readRemaining int64 // bytes remaining in current frame.
 	readFinal     bool  // true the current message has more frames.
-	readSeq       int   // incremented to invalidate message readers.
 	readLength    int64 // Message size.
 	readLimit     int64 // Maximum message size.
 	readMaskPos   int
 	readMaskKey   [4]byte
 	handlePong    func(string) error
 	handlePing    func(string) error
+	handleClose   func(int, string) error
+	readErrCount  int
+	messageReader *messageReader // the current low-level reader
+
+	readDecompress         bool // whether last read frame had RSV1 set
+	newDecompressionReader func(io.Reader) io.ReadCloser
 }
 
 func newConn(conn net.Conn, isServer bool, readBufferSize, writeBufferSize int) *Conn {
+	return newConnBRW(conn, isServer, readBufferSize, writeBufferSize, nil)
+}
+
+type writeHook struct {
+	p []byte
+}
+
+func (wh *writeHook) Write(p []byte) (int, error) {
+	wh.p = p
+	return len(p), nil
+}
+
+func newConnBRW(conn net.Conn, isServer bool, readBufferSize, writeBufferSize int, brw *bufio.ReadWriter) *Conn {
 	mu := make(chan bool, 1)
 	mu <- true
 
-	if readBufferSize == 0 {
-		readBufferSize = defaultReadBufferSize
+	var br *bufio.Reader
+	if readBufferSize == 0 && brw != nil && brw.Reader != nil {
+		// Reuse the supplied bufio.Reader if the buffer has a useful size.
+		// This code assumes that peek on a reader returns
+		// bufio.Reader.buf[:0].
+		brw.Reader.Reset(conn)
+		if p, err := brw.Reader.Peek(0); err == nil && cap(p) >= 256 {
+			br = brw.Reader
+		}
 	}
-	if writeBufferSize == 0 {
-		writeBufferSize = defaultWriteBufferSize
+	if br == nil {
+		if readBufferSize == 0 {
+			readBufferSize = defaultReadBufferSize
+		}
+		if readBufferSize < maxControlFramePayloadSize {
+			readBufferSize = maxControlFramePayloadSize
+		}
+		br = bufio.NewReaderSize(conn, readBufferSize)
+	}
+
+	var writeBuf []byte
+	if writeBufferSize == 0 && brw != nil && brw.Writer != nil {
+		// Use the bufio.Writer's buffer if the buffer has a useful size. This
+		// code assumes that bufio.Writer.buf[:1] is passed to the
+		// bufio.Writer's underlying writer.
+		var wh writeHook
+		brw.Writer.Reset(&wh)
+		brw.Writer.WriteByte(0)
+		brw.Flush()
+		if cap(wh.p) >= maxFrameHeaderSize+256 {
+			writeBuf = wh.p[:cap(wh.p)]
+		}
+	}
+
+	if writeBuf == nil {
+		if writeBufferSize == 0 {
+			writeBufferSize = defaultWriteBufferSize
+		}
+		writeBuf = make([]byte, writeBufferSize+maxFrameHeaderSize)
 	}
 
 	c := &Conn{
-		isServer:       isServer,
-		br:             bufio.NewReaderSize(conn, readBufferSize),
-		conn:           conn,
-		mu:             mu,
-		readFinal:      true,
-		writeBuf:       make([]byte, writeBufferSize+maxFrameHeaderSize),
-		writeFrameType: noFrame,
-		writePos:       maxFrameHeaderSize,
+		isServer:               isServer,
+		br:                     br,
+		conn:                   conn,
+		mu:                     mu,
+		readFinal:              true,
+		writeBuf:               writeBuf,
+		enableWriteCompression: true,
+		compressionLevel:       defaultCompressionLevel,
 	}
+	c.SetCloseHandler(nil)
 	c.SetPingHandler(nil)
 	c.SetPongHandler(nil)
 	return c
@@ -214,29 +360,40 @@ func (c *Conn) RemoteAddr() net.Addr {
 
 // Write methods
 
+func (c *Conn) writeFatal(err error) error {
+	err = hideTempErr(err)
+	c.writeErrMu.Lock()
+	if c.writeErr == nil {
+		c.writeErr = err
+	}
+	c.writeErrMu.Unlock()
+	return err
+}
+
 func (c *Conn) write(frameType int, deadline time.Time, bufs ...[]byte) error {
 	<-c.mu
 	defer func() { c.mu <- true }()
 
-	if c.closeSent {
-		return ErrCloseSent
-	} else if frameType == CloseMessage {
-		c.closeSent = true
+	c.writeErrMu.Lock()
+	err := c.writeErr
+	c.writeErrMu.Unlock()
+	if err != nil {
+		return err
 	}
 
 	c.conn.SetWriteDeadline(deadline)
 	for _, buf := range bufs {
 		if len(buf) > 0 {
-			n, err := c.conn.Write(buf)
-			if n != len(buf) {
-				// Close on partial write.
-				c.conn.Close()
-			}
+			_, err := c.conn.Write(buf)
 			if err != nil {
-				return err
+				return c.writeFatal(err)
 			}
 		}
 	}
+
+	if frameType == CloseMessage {
+		c.writeFatal(ErrCloseSent)
+	}
 	return nil
 }
 
@@ -285,63 +442,104 @@ func (c *Conn) WriteControl(messageType int, data []byte, deadline time.Time) er
 	}
 	defer func() { c.mu <- true }()
 
-	if c.closeSent {
-		return ErrCloseSent
-	} else if messageType == CloseMessage {
-		c.closeSent = true
+	c.writeErrMu.Lock()
+	err := c.writeErr
+	c.writeErrMu.Unlock()
+	if err != nil {
+		return err
 	}
 
 	c.conn.SetWriteDeadline(deadline)
-	n, err := c.conn.Write(buf)
-	if n != 0 && n != len(buf) {
-		c.conn.Close()
+	_, err = c.conn.Write(buf)
+	if err != nil {
+		return c.writeFatal(err)
+	}
+	if messageType == CloseMessage {
+		c.writeFatal(ErrCloseSent)
 	}
 	return err
 }
 
-// NextWriter returns a writer for the next message to send.  The writer's
-// Close method flushes the complete message to the network.
-//
-// There can be at most one open writer on a connection. NextWriter closes the
-// previous writer if the application has not already done so.
-//
-// The NextWriter method and the writers returned from the method cannot be
-// accessed by more than one goroutine at a time.
-func (c *Conn) NextWriter(messageType int) (io.WriteCloser, error) {
-	if c.writeErr != nil {
-		return nil, c.writeErr
-	}
-
-	if c.writeFrameType != noFrame {
-		if err := c.flushFrame(true, nil); err != nil {
-			return nil, err
-		}
+func (c *Conn) prepWrite(messageType int) error {
+	// Close previous writer if not already closed by the application. It's
+	// probably better to return an error in this situation, but we cannot
+	// change this without breaking existing applications.
+	if c.writer != nil {
+		c.writer.Close()
+		c.writer = nil
 	}
 
 	if !isControl(messageType) && !isData(messageType) {
-		return nil, errBadWriteOpCode
+		return errBadWriteOpCode
 	}
 
-	c.writeFrameType = messageType
-	return messageWriter{c, c.writeSeq}, nil
+	c.writeErrMu.Lock()
+	err := c.writeErr
+	c.writeErrMu.Unlock()
+	return err
 }
 
-func (c *Conn) flushFrame(final bool, extra []byte) error {
-	length := c.writePos - maxFrameHeaderSize + len(extra)
-
-	// Check for invalid control frames.
-	if isControl(c.writeFrameType) &&
-		(!final || length > maxControlFramePayloadSize) {
-		c.writeSeq++
-		c.writeFrameType = noFrame
-		c.writePos = maxFrameHeaderSize
-		return errInvalidControlFrame
+// NextWriter returns a writer for the next message to send. The writer's Close
+// method flushes the complete message to the network.
+//
+// There can be at most one open writer on a connection. NextWriter closes the
+// previous writer if the application has not already done so.
+func (c *Conn) NextWriter(messageType int) (io.WriteCloser, error) {
+	if err := c.prepWrite(messageType); err != nil {
+		return nil, err
 	}
 
-	b0 := byte(c.writeFrameType)
+	mw := &messageWriter{
+		c:         c,
+		frameType: messageType,
+		pos:       maxFrameHeaderSize,
+	}
+	c.writer = mw
+	if c.newCompressionWriter != nil && c.enableWriteCompression && isData(messageType) {
+		w := c.newCompressionWriter(c.writer, c.compressionLevel)
+		mw.compress = true
+		c.writer = w
+	}
+	return c.writer, nil
+}
+
+type messageWriter struct {
+	c         *Conn
+	compress  bool // whether next call to flushFrame should set RSV1
+	pos       int  // end of data in writeBuf.
+	frameType int  // type of the current frame.
+	err       error
+}
+
+func (w *messageWriter) fatal(err error) error {
+	if w.err != nil {
+		w.err = err
+		w.c.writer = nil
+	}
+	return err
+}
+
+// flushFrame writes buffered data and extra as a frame to the network. The
+// final argument indicates that this is the last frame in the message.
+func (w *messageWriter) flushFrame(final bool, extra []byte) error {
+	c := w.c
+	length := w.pos - maxFrameHeaderSize + len(extra)
+
+	// Check for invalid control frames.
+	if isControl(w.frameType) &&
+		(!final || length > maxControlFramePayloadSize) {
+		return w.fatal(errInvalidControlFrame)
+	}
+
+	b0 := byte(w.frameType)
 	if final {
 		b0 |= finalBit
 	}
+	if w.compress {
+		b0 |= rsv1Bit
+	}
+	w.compress = false
+
 	b1 := byte(0)
 	if !c.isServer {
 		b1 |= maskBit
@@ -373,49 +571,50 @@ func (c *Conn) flushFrame(final bool, extra []byte) error {
 	if !c.isServer {
 		key := newMaskKey()
 		copy(c.writeBuf[maxFrameHeaderSize-4:], key[:])
-		maskBytes(key, 0, c.writeBuf[maxFrameHeaderSize:c.writePos])
+		maskBytes(key, 0, c.writeBuf[maxFrameHeaderSize:w.pos])
 		if len(extra) > 0 {
-			c.writeErr = errors.New("websocket: internal error, extra used in client mode")
-			return c.writeErr
+			return c.writeFatal(errors.New("websocket: internal error, extra used in client mode"))
 		}
 	}
 
-	// Write the buffers to the connection.
-	c.writeErr = c.write(c.writeFrameType, c.writeDeadline, c.writeBuf[framePos:c.writePos], extra)
+	// Write the buffers to the connection with best-effort detection of
+	// concurrent writes. See the concurrency section in the package
+	// documentation for more info.
+
+	if c.isWriting {
+		panic("concurrent write to websocket connection")
+	}
+	c.isWriting = true
+
+	err := c.write(w.frameType, c.writeDeadline, c.writeBuf[framePos:w.pos], extra)
+
+	if !c.isWriting {
+		panic("concurrent write to websocket connection")
+	}
+	c.isWriting = false
+
+	if err != nil {
+		return w.fatal(err)
+	}
+
+	if final {
+		c.writer = nil
+		return nil
+	}
 
 	// Setup for next frame.
-	c.writePos = maxFrameHeaderSize
-	c.writeFrameType = continuationFrame
-	if final {
-		c.writeSeq++
-		c.writeFrameType = noFrame
-	}
-	return c.writeErr
-}
-
-type messageWriter struct {
-	c   *Conn
-	seq int
-}
-
-func (w messageWriter) err() error {
-	c := w.c
-	if c.writeSeq != w.seq {
-		return errWriteClosed
-	}
-	if c.writeErr != nil {
-		return c.writeErr
-	}
+	w.pos = maxFrameHeaderSize
+	w.frameType = continuationFrame
 	return nil
 }
 
-func (w messageWriter) ncopy(max int) (int, error) {
-	n := len(w.c.writeBuf) - w.c.writePos
+func (w *messageWriter) ncopy(max int) (int, error) {
+	n := len(w.c.writeBuf) - w.pos
 	if n <= 0 {
-		if err := w.c.flushFrame(false, nil); err != nil {
+		if err := w.flushFrame(false, nil); err != nil {
 			return 0, err
 		}
-		n = len(w.c.writeBuf) - w.c.writePos
+		n = len(w.c.writeBuf) - w.pos
 	}
 	if n > max {
 		n = max
@@ -423,14 +622,14 @@ func (w messageWriter) ncopy(max int) (int, error) {
 	return n, nil
 }
 
-func (w messageWriter) write(final bool, p []byte) (int, error) {
-	if err := w.err(); err != nil {
-		return 0, err
+func (w *messageWriter) Write(p []byte) (int, error) {
+	if w.err != nil {
+		return 0, w.err
 	}
 
 	if len(p) > 2*len(w.c.writeBuf) && w.c.isServer {
 		// Don't buffer large messages.
-		err := w.c.flushFrame(final, p)
+		err := w.flushFrame(false, p)
 		if err != nil {
 			return 0, err
 		}
@@ -443,20 +642,16 @@ func (w messageWriter) write(final bool, p []byte) (int, error) {
 		if err != nil {
 			return 0, err
 		}
-		copy(w.c.writeBuf[w.c.writePos:], p[:n])
-		w.c.writePos += n
+		copy(w.c.writeBuf[w.pos:], p[:n])
+		w.pos += n
 		p = p[n:]
 	}
 	return nn, nil
 }
 
-func (w messageWriter) Write(p []byte) (int, error) {
-	return w.write(false, p)
-}
-
-func (w messageWriter) WriteString(p string) (int, error) {
-	if err := w.err(); err != nil {
-		return 0, err
+func (w *messageWriter) WriteString(p string) (int, error) {
+	if w.err != nil {
+		return 0, w.err
 	}
 
 	nn := len(p)
@@ -465,27 +660,27 @@ func (w messageWriter) WriteString(p string) (int, error) {
 		if err != nil {
 			return 0, err
 		}
-		copy(w.c.writeBuf[w.c.writePos:], p[:n])
-		w.c.writePos += n
+		copy(w.c.writeBuf[w.pos:], p[:n])
+		w.pos += n
 		p = p[n:]
 	}
 	return nn, nil
 }
 
-func (w messageWriter) ReadFrom(r io.Reader) (nn int64, err error) {
-	if err := w.err(); err != nil {
-		return 0, err
+func (w *messageWriter) ReadFrom(r io.Reader) (nn int64, err error) {
+	if w.err != nil {
+		return 0, w.err
 	}
 	for {
-		if w.c.writePos == len(w.c.writeBuf) {
-			err = w.c.flushFrame(false, nil)
+		if w.pos == len(w.c.writeBuf) {
+			err = w.flushFrame(false, nil)
 			if err != nil {
 				break
 			}
 		}
 		var n int
-		n, err = r.Read(w.c.writeBuf[w.c.writePos:])
-		w.c.writePos += n
+		n, err = r.Read(w.c.writeBuf[w.pos:])
+		w.pos += n
 		nn += int64(n)
 		if err != nil {
 			if err == io.EOF {
@@ -497,30 +692,64 @@ func (w messageWriter) ReadFrom(r io.Reader) (nn int64, err error) {
 	return nn, err
 }
 
-func (w messageWriter) Close() error {
-	if err := w.err(); err != nil {
+func (w *messageWriter) Close() error {
+	if w.err != nil {
+		return w.err
+	}
+	if err := w.flushFrame(true, nil); err != nil {
 		return err
 	}
-	return w.c.flushFrame(true, nil)
+	w.err = errWriteClosed
+	return nil
+}
+
+// WritePreparedMessage writes prepared message into connection.
+func (c *Conn) WritePreparedMessage(pm *PreparedMessage) error {
+	frameType, frameData, err := pm.frame(prepareKey{
+		isServer:         c.isServer,
+		compress:         c.newCompressionWriter != nil && c.enableWriteCompression && isData(pm.messageType),
+		compressionLevel: c.compressionLevel,
+	})
+	if err != nil {
+		return err
+	}
+	if c.isWriting {
+		panic("concurrent write to websocket connection")
+	}
+	c.isWriting = true
+	err = c.write(frameType, c.writeDeadline, frameData, nil)
+	if !c.isWriting {
+		panic("concurrent write to websocket connection")
+	}
+	c.isWriting = false
+	return err
 }
 
 // WriteMessage is a helper method for getting a writer using NextWriter,
 // writing the message and closing the writer.
 func (c *Conn) WriteMessage(messageType int, data []byte) error {
-	wr, err := c.NextWriter(messageType)
+
+	if c.isServer && (c.newCompressionWriter == nil || !c.enableWriteCompression) {
+		// Fast path with no allocations and single frame.
+
+		if err := c.prepWrite(messageType); err != nil {
+			return err
+		}
+		mw := messageWriter{c: c, frameType: messageType, pos: maxFrameHeaderSize}
+		n := copy(c.writeBuf[mw.pos:], data)
+		mw.pos += n
+		data = data[n:]
+		return mw.flushFrame(true, data)
+	}
+
+	w, err := c.NextWriter(messageType)
 	if err != nil {
 		return err
 	}
-	w := wr.(messageWriter)
-	if _, err := w.write(true, data); err != nil {
+	if _, err = w.Write(data); err != nil {
 		return err
 	}
-	if c.writeSeq == w.seq {
-		if err := c.flushFrame(true, nil); err != nil {
-			return err
-		}
-	}
-	return nil
+	return w.Close()
 }
 
 // SetWriteDeadline sets the write deadline on the underlying network
@@ -534,22 +763,6 @@ func (c *Conn) SetWriteDeadline(t time.Time) error {
 
 // Read methods
 
-// readFull is like io.ReadFull except that io.EOF is never returned.
-func (c *Conn) readFull(p []byte) (err error) {
-	var n int
-	for n < len(p) && err == nil {
-		var nn int
-		nn, err = c.br.Read(p[n:])
-		n += nn
-	}
-	if n == len(p) {
-		err = nil
-	} else if err == io.EOF {
-		err = errUnexpectedEOF
-	}
-	return
-}
-
 func (c *Conn) advanceFrame() (int, error) {
 
 	// 1. Skip remainder of previous frame.
@@ -562,19 +775,24 @@ func (c *Conn) advanceFrame() (int, error) {
 
 	// 2. Read and parse first two bytes of frame header.
 
-	var b [8]byte
-	if err := c.readFull(b[:2]); err != nil {
+	p, err := c.read(2)
+	if err != nil {
 		return noFrame, err
 	}
 
-	final := b[0]&finalBit != 0
-	frameType := int(b[0] & 0xf)
-	reserved := int((b[0] >> 4) & 0x7)
-	mask := b[1]&maskBit != 0
-	c.readRemaining = int64(b[1] & 0x7f)
+	final := p[0]&finalBit != 0
+	frameType := int(p[0] & 0xf)
+	mask := p[1]&maskBit != 0
+	c.readRemaining = int64(p[1] & 0x7f)
 
-	if reserved != 0 {
-		return noFrame, c.handleProtocolError("unexpected reserved bits " + strconv.Itoa(reserved))
+	c.readDecompress = false
+	if c.newDecompressionReader != nil && (p[0]&rsv1Bit) != 0 {
+		c.readDecompress = true
+		p[0] &^= rsv1Bit
+	}
+
+	if rsv := p[0] & (rsv1Bit | rsv2Bit | rsv3Bit); rsv != 0 {
+		return noFrame, c.handleProtocolError("unexpected reserved bits 0x" + strconv.FormatInt(int64(rsv), 16))
 	}
 
 	switch frameType {
@@ -603,15 +821,17 @@ func (c *Conn) advanceFrame() (int, error) {
 
 	switch c.readRemaining {
 	case 126:
-		if err := c.readFull(b[:2]); err != nil {
+		p, err := c.read(2)
+		if err != nil {
 			return noFrame, err
 		}
-		c.readRemaining = int64(binary.BigEndian.Uint16(b[:2]))
+		c.readRemaining = int64(binary.BigEndian.Uint16(p))
 	case 127:
-		if err := c.readFull(b[:8]); err != nil {
+		p, err := c.read(8)
+		if err != nil {
 			return noFrame, err
 		}
-		c.readRemaining = int64(binary.BigEndian.Uint64(b[:8]))
+		c.readRemaining = int64(binary.BigEndian.Uint64(p))
 	}
 
 	// 4. Handle frame masking.
@@ -622,9 +842,11 @@ func (c *Conn) advanceFrame() (int, error) {
 
 	if mask {
 		c.readMaskPos = 0
-		if err := c.readFull(c.readMaskKey[:]); err != nil {
+		p, err := c.read(len(c.readMaskKey))
+		if err != nil {
 			return noFrame, err
 		}
+		copy(c.readMaskKey[:], p)
 	}
 
 	// 5. For text and binary messages, enforce read limit and return.
@@ -644,9 +866,9 @@ func (c *Conn) advanceFrame() (int, error) {
 
 	var payload []byte
 	if c.readRemaining > 0 {
-		payload = make([]byte, c.readRemaining)
+		payload, err = c.read(int(c.readRemaining))
 		c.readRemaining = 0
-		if err := c.readFull(payload); err != nil {
+		if err != nil {
 			return noFrame, err
 		}
 		if c.isServer {
@@ -666,19 +888,22 @@ func (c *Conn) advanceFrame() (int, error) {
 			return noFrame, err
 		}
 	case CloseMessage:
-		c.WriteControl(CloseMessage, []byte{}, time.Now().Add(writeWait))
 		closeCode := CloseNoStatusReceived
 		closeText := ""
 		if len(payload) >= 2 {
 			closeCode = int(binary.BigEndian.Uint16(payload))
+			if !isValidReceivedCloseCode(closeCode) {
+				return noFrame, c.handleProtocolError("invalid close code")
+			}
 			closeText = string(payload[2:])
+			if !utf8.ValidString(closeText) {
+				return noFrame, c.handleProtocolError("invalid utf8 payload in close frame")
+			}
 		}
-		switch closeCode {
-		case CloseNormalClosure, CloseGoingAway:
-			return noFrame, io.EOF
-		default:
-			return noFrame, &closeError{code: closeCode, text: closeText}
+		if err := c.handleClose(closeCode, closeText); err != nil {
+			return noFrame, err
 		}
+		return noFrame, &CloseError{Code: closeCode, Text: closeText}
 	}
 
 	return frameType, nil
@@ -695,11 +920,18 @@ func (c *Conn) handleProtocolError(message string) error {
 // There can be at most one open reader on a connection. NextReader discards
 // the previous message if the application has not already consumed it.
 //
-// The NextReader method and the readers returned from the method cannot be
-// accessed by more than one goroutine at a time.
+// Applications must break out of the application's read loop when this method
+// returns a non-nil error value. Errors returned from this method are
+// permanent. Once this method returns a non-nil error, all subsequent calls to
+// this method return the same error.
 func (c *Conn) NextReader() (messageType int, r io.Reader, err error) {
+	// Close previous reader, only relevant for decompression.
+	if c.reader != nil {
+		c.reader.Close()
+		c.reader = nil
+	}
 
-	c.readSeq++
+	c.messageReader = nil
 	c.readLength = 0
 
 	for c.readErr == nil {
@@ -709,59 +941,77 @@ func (c *Conn) NextReader() (messageType int, r io.Reader, err error) {
 			break
 		}
 		if frameType == TextMessage || frameType == BinaryMessage {
-			return frameType, messageReader{c, c.readSeq}, nil
+			c.messageReader = &messageReader{c}
+			c.reader = c.messageReader
+			if c.readDecompress {
+				c.reader = c.newDecompressionReader(c.reader)
+			}
+			return frameType, c.reader, nil
 		}
 	}
+
+	// Applications that do handle the error returned from this method spin in
+	// tight loop on connection failure. To help application developers detect
+	// this error, panic on repeated reads to the failed connection.
+	c.readErrCount++
+	if c.readErrCount >= 1000 {
+		panic("repeated read on failed websocket connection")
+	}
+
 	return noFrame, nil, c.readErr
 }
 
-type messageReader struct {
-	c   *Conn
-	seq int
-}
+type messageReader struct{ c *Conn }
 
-func (r messageReader) Read(b []byte) (int, error) {
-
-	if r.seq != r.c.readSeq {
+func (r *messageReader) Read(b []byte) (int, error) {
+	c := r.c
+	if c.messageReader != r {
 		return 0, io.EOF
 	}
 
-	for r.c.readErr == nil {
+	for c.readErr == nil {
 
-		if r.c.readRemaining > 0 {
-			if int64(len(b)) > r.c.readRemaining {
-				b = b[:r.c.readRemaining]
+		if c.readRemaining > 0 {
+			if int64(len(b)) > c.readRemaining {
+				b = b[:c.readRemaining]
 			}
-			n, err := r.c.br.Read(b)
-			r.c.readErr = hideTempErr(err)
-			if r.c.isServer {
-				r.c.readMaskPos = maskBytes(r.c.readMaskKey, r.c.readMaskPos, b[:n])
+			n, err := c.br.Read(b)
+			c.readErr = hideTempErr(err)
+			if c.isServer {
+				c.readMaskPos = maskBytes(c.readMaskKey, c.readMaskPos, b[:n])
 			}
-			r.c.readRemaining -= int64(n)
-			return n, r.c.readErr
+			c.readRemaining -= int64(n)
+			if c.readRemaining > 0 && c.readErr == io.EOF {
+				c.readErr = errUnexpectedEOF
+			}
+			return n, c.readErr
 		}
 
-		if r.c.readFinal {
-			r.c.readSeq++
+		if c.readFinal {
+			c.messageReader = nil
 			return 0, io.EOF
 		}
 
-		frameType, err := r.c.advanceFrame()
+		frameType, err := c.advanceFrame()
 		switch {
 		case err != nil:
-			r.c.readErr = hideTempErr(err)
+			c.readErr = hideTempErr(err)
 		case frameType == TextMessage || frameType == BinaryMessage:
-			r.c.readErr = errors.New("websocket: internal error, unexpected text or binary in Reader")
+			c.readErr = errors.New("websocket: internal error, unexpected text or binary in Reader")
 		}
 	}
 
-	err := r.c.readErr
-	if err == io.EOF && r.seq == r.c.readSeq {
+	err := c.readErr
+	if err == io.EOF && c.messageReader == r {
 		err = errUnexpectedEOF
 	}
 	return 0, err
 }
 
+func (r *messageReader) Close() error {
+	return nil
+}
+
 // ReadMessage is a helper method for getting a reader using NextReader and
 // reading from that reader to a buffer.
 func (c *Conn) ReadMessage() (messageType int, p []byte, err error) {
@@ -789,21 +1039,76 @@ func (c *Conn) SetReadLimit(limit int64) {
 	c.readLimit = limit
 }
 
+// CloseHandler returns the current close handler
+func (c *Conn) CloseHandler() func(code int, text string) error {
+	return c.handleClose
+}
+
+// SetCloseHandler sets the handler for close messages received from the peer.
+// The code argument to h is the received close code or CloseNoStatusReceived
+// if the close message is empty. The default close handler sends a close frame
+// back to the peer.
+//
+// The application must read the connection to process close messages as
+// described in the section on Control Frames above.
+//
+// The connection read methods return a CloseError when a close frame is
+// received. Most applications should handle close messages as part of their
+// normal error handling. Applications should only set a close handler when the
+// application must perform some action before sending a close frame back to
+// the peer.
+func (c *Conn) SetCloseHandler(h func(code int, text string) error) {
+	if h == nil {
+		h = func(code int, text string) error {
+			message := []byte{}
+			if code != CloseNoStatusReceived {
+				message = FormatCloseMessage(code, "")
+			}
+			c.WriteControl(CloseMessage, message, time.Now().Add(writeWait))
+			return nil
+		}
+	}
+	c.handleClose = h
+}
+
+// PingHandler returns the current ping handler
+func (c *Conn) PingHandler() func(appData string) error {
+	return c.handlePing
+}
+
 // SetPingHandler sets the handler for ping messages received from the peer.
-// The default ping handler sends a pong to the peer.
-func (c *Conn) SetPingHandler(h func(string) error) {
+// The appData argument to h is the PING frame application data. The default
+// ping handler sends a pong to the peer.
+//
+// The application must read the connection to process ping messages as
+// described in the section on Control Frames above.
+func (c *Conn) SetPingHandler(h func(appData string) error) {
 	if h == nil {
 		h = func(message string) error {
-			c.WriteControl(PongMessage, []byte(message), time.Now().Add(writeWait))
-			return nil
+			err := c.WriteControl(PongMessage, []byte(message), time.Now().Add(writeWait))
+			if err == ErrCloseSent {
+				return nil
+			} else if e, ok := err.(net.Error); ok && e.Temporary() {
+				return nil
+			}
+			return err
 		}
 	}
 	c.handlePing = h
 }
 
+// PongHandler returns the current pong handler
+func (c *Conn) PongHandler() func(appData string) error {
+	return c.handlePong
+}
+
 // SetPongHandler sets the handler for pong messages received from the peer.
-// The default pong handler does nothing.
-func (c *Conn) SetPongHandler(h func(string) error) {
+// The appData argument to h is the PONG frame application data. The default
+// pong handler does nothing.
+//
+// The application must read the connection to process ping messages as
+// described in the section on Control Frames above.
+func (c *Conn) SetPongHandler(h func(appData string) error) {
 	if h == nil {
 		h = func(string) error { return nil }
 	}
@@ -816,6 +1121,25 @@ func (c *Conn) UnderlyingConn() net.Conn {
 	return c.conn
 }
 
+// EnableWriteCompression enables and disables write compression of
+// subsequent text and binary messages. This function is a noop if
+// compression was not negotiated with the peer.
+func (c *Conn) EnableWriteCompression(enable bool) {
+	c.enableWriteCompression = enable
+}
+
+// SetCompressionLevel sets the flate compression level for subsequent text and
+// binary messages. This function is a noop if compression was not negotiated
+// with the peer. See the compress/flate package for a description of
+// compression levels.
+func (c *Conn) SetCompressionLevel(level int) error {
+	if !isValidCompressionLevel(level) {
+		return errors.New("websocket: invalid compression level")
+	}
+	c.compressionLevel = level
+	return nil
+}
+
 // FormatCloseMessage formats closeCode and text as a WebSocket close message.
 func FormatCloseMessage(closeCode int, text string) []byte {
 	buf := make([]byte, 2+len(text))
diff --git a/vendor/github.com/gorilla/websocket/conn_read.go b/vendor/github.com/gorilla/websocket/conn_read.go
new file mode 100644
index 00000000000..1ea15059ee1
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/conn_read.go
@@ -0,0 +1,18 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.5
+
+package websocket
+
+import "io"
+
+func (c *Conn) read(n int) ([]byte, error) {
+	p, err := c.br.Peek(n)
+	if err == io.EOF {
+		err = errUnexpectedEOF
+	}
+	c.br.Discard(len(p))
+	return p, err
+}
diff --git a/vendor/github.com/gorilla/websocket/conn_read_legacy.go b/vendor/github.com/gorilla/websocket/conn_read_legacy.go
new file mode 100644
index 00000000000..018541cf6cb
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/conn_read_legacy.go
@@ -0,0 +1,21 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.5
+
+package websocket
+
+import "io"
+
+func (c *Conn) read(n int) ([]byte, error) {
+	p, err := c.br.Peek(n)
+	if err == io.EOF {
+		err = errUnexpectedEOF
+	}
+	if len(p) > 0 {
+		// advance over the bytes just read
+		io.ReadFull(c.br, p)
+	}
+	return p, err
+}
diff --git a/vendor/github.com/gorilla/websocket/doc.go b/vendor/github.com/gorilla/websocket/doc.go
index f52925dd11a..f5ff0823da7 100644
--- a/vendor/github.com/gorilla/websocket/doc.go
+++ b/vendor/github.com/gorilla/websocket/doc.go
@@ -6,9 +6,8 @@
 //
 // Overview
 //
-// The Conn type represents a WebSocket connection. A server application uses
-// the Upgrade function from an Upgrader object with a HTTP request handler
-// to get a pointer to a Conn:
+// The Conn type represents a WebSocket connection. A server application calls
+// the Upgrader.Upgrade method from an HTTP request handler to get a *Conn:
 //
 //  var upgrader = websocket.Upgrader{
 //      ReadBufferSize:  1024,
@@ -33,7 +32,7 @@
 //      if err != nil {
 //          return
 //      }
-//      if err = conn.WriteMessage(messageType, p); err != nil {
+//      if err := conn.WriteMessage(messageType, p); err != nil {
 //          return err
 //      }
 //  }
@@ -46,8 +45,7 @@
 // method to get an io.WriteCloser, write the message to the writer and close
 // the writer when done. To receive a message, call the connection NextReader
 // method to get an io.Reader and read until io.EOF is returned. This snippet
-// snippet shows how to echo messages using the NextWriter and NextReader
-// methods:
+// shows how to echo messages using the NextWriter and NextReader methods:
 //
 //  for {
 //      messageType, r, err := conn.NextReader()
@@ -86,31 +84,23 @@
 // and pong. Call the connection WriteControl, WriteMessage or NextWriter
 // methods to send a control message to the peer.
 //
-// Connections handle received ping and pong messages by invoking a callback
-// function set with SetPingHandler and SetPongHandler methods. These callback
-// functions can be invoked from the ReadMessage method, the NextReader method
-// or from a call to the data message reader returned from NextReader.
+// Connections handle received close messages by sending a close message to the
+// peer and returning a *CloseError from the the NextReader, ReadMessage or the
+// message Read method.
 //
-// Connections handle received close messages by returning an error from the
-// ReadMessage method, the NextReader method or from a call to the data message
-// reader returned from NextReader.
-//
-// Concurrency
-//
-// Connections do not support concurrent calls to the write methods
-// (NextWriter, SetWriteDeadline, WriteMessage) or concurrent calls to the read
-// methods methods (NextReader, SetReadDeadline, ReadMessage).  Connections do
-// support a concurrent reader and writer.
-//
-// The Close and WriteControl methods can be called concurrently with all other
+// Connections handle received ping and pong messages by invoking callback
+// functions set with SetPingHandler and SetPongHandler methods. The callback
+// functions are called from the NextReader, ReadMessage and the message Read
 // methods.
 //
-// Read is Required
+// The default ping handler sends a pong to the peer. The application's reading
+// goroutine can block for a short time while the handler writes the pong data
+// to the connection.
 //
-// The application must read the connection to process ping and close messages
-// sent from the peer. If the application is not otherwise interested in
-// messages from the peer, then the application should start a goroutine to read
-// and discard messages from the peer. A simple example is:
+// The application must read the connection to process ping, pong and close
+// messages sent from the peer. If the application is not otherwise interested
+// in messages from the peer, then the application should start a goroutine to
+// read and discard messages from the peer. A simple example is:
 //
 //  func readLoop(c *websocket.Conn) {
 //      for {
@@ -121,6 +111,20 @@
 //      }
 //  }
 //
+// Concurrency
+//
+// Connections support one concurrent reader and one concurrent writer.
+//
+// Applications are responsible for ensuring that no more than one goroutine
+// calls the write methods (NextWriter, SetWriteDeadline, WriteMessage,
+// WriteJSON, EnableWriteCompression, SetCompressionLevel) concurrently and
+// that no more than one goroutine calls the read methods (NextReader,
+// SetReadDeadline, ReadMessage, ReadJSON, SetPongHandler, SetPingHandler)
+// concurrently.
+//
+// The Close and WriteControl methods can be called concurrently with all other
+// methods.
+//
 // Origin Considerations
 //
 // Web browsers allow Javascript applications to open a WebSocket connection to
@@ -138,11 +142,38 @@
 // An application can allow connections from any origin by specifying a
 // function that always returns true:
 //
-//    var upgrader = websocket.Upgrader{
+//  var upgrader = websocket.Upgrader{
 //      CheckOrigin: func(r *http.Request) bool { return true },
-//   }
+//  }
 //
-// The deprecated Upgrade function does not enforce an origin policy. It's the
-// application's responsibility to check the Origin header before calling
-// Upgrade.
+// The deprecated package-level Upgrade function does not perform origin
+// checking. The application is responsible for checking the Origin header
+// before calling the Upgrade function.
+//
+// Compression EXPERIMENTAL
+//
+// Per message compression extensions (RFC 7692) are experimentally supported
+// by this package in a limited capacity. Setting the EnableCompression option
+// to true in Dialer or Upgrader will attempt to negotiate per message deflate
+// support.
+//
+//  var upgrader = websocket.Upgrader{
+//      EnableCompression: true,
+//  }
+//
+// If compression was successfully negotiated with the connection's peer, any
+// message received in compressed form will be automatically decompressed.
+// All Read methods will return uncompressed bytes.
+//
+// Per message compression of messages written to a connection can be enabled
+// or disabled by calling the corresponding Conn method:
+//
+//  conn.EnableWriteCompression(false)
+//
+// Currently this package does not support compression with "context takeover".
+// This means that messages must be compressed and decompressed in isolation,
+// without retaining sliding window or dictionary state across messages. For
+// more details refer to RFC 7692.
+//
+// Use of compression is experimental and may result in decreased performance.
 package websocket
diff --git a/vendor/github.com/gorilla/websocket/json.go b/vendor/github.com/gorilla/websocket/json.go
index 18e62f2256c..dc2c1f6415f 100644
--- a/vendor/github.com/gorilla/websocket/json.go
+++ b/vendor/github.com/gorilla/websocket/json.go
@@ -9,12 +9,14 @@ import (
 	"io"
 )
 
-// WriteJSON is deprecated, use c.WriteJSON instead.
+// WriteJSON writes the JSON encoding of v as a message.
+//
+// Deprecated: Use c.WriteJSON instead.
 func WriteJSON(c *Conn, v interface{}) error {
 	return c.WriteJSON(v)
 }
 
-// WriteJSON writes the JSON encoding of v to the connection.
+// WriteJSON writes the JSON encoding of v as a message.
 //
 // See the documentation for encoding/json Marshal for details about the
 // conversion of Go values to JSON.
@@ -31,7 +33,10 @@ func (c *Conn) WriteJSON(v interface{}) error {
 	return err2
 }
 
-// ReadJSON is deprecated, use c.ReadJSON instead.
+// ReadJSON reads the next JSON-encoded message from the connection and stores
+// it in the value pointed to by v.
+//
+// Deprecated: Use c.ReadJSON instead.
 func ReadJSON(c *Conn, v interface{}) error {
 	return c.ReadJSON(v)
 }
@@ -48,9 +53,7 @@ func (c *Conn) ReadJSON(v interface{}) error {
 	}
 	err = json.NewDecoder(r).Decode(v)
 	if err == io.EOF {
-		// Decode returns io.EOF when the message is empty or all whitespace.
-		// Convert to io.ErrUnexpectedEOF so that application can distinguish
-		// between an error reading the JSON value and the connection closing.
+		// One value is expected in the message.
 		err = io.ErrUnexpectedEOF
 	}
 	return err
diff --git a/vendor/github.com/gorilla/websocket/mask.go b/vendor/github.com/gorilla/websocket/mask.go
new file mode 100644
index 00000000000..6a88bbc7434
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/mask.go
@@ -0,0 +1,55 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.  Use of
+// this source code is governed by a BSD-style license that can be found in the
+// LICENSE file.
+
+// +build !appengine
+
+package websocket
+
+import "unsafe"
+
+const wordSize = int(unsafe.Sizeof(uintptr(0)))
+
+func maskBytes(key [4]byte, pos int, b []byte) int {
+
+	// Mask one byte at a time for small buffers.
+	if len(b) < 2*wordSize {
+		for i := range b {
+			b[i] ^= key[pos&3]
+			pos++
+		}
+		return pos & 3
+	}
+
+	// Mask one byte at a time to word boundary.
+	if n := int(uintptr(unsafe.Pointer(&b[0]))) % wordSize; n != 0 {
+		n = wordSize - n
+		for i := range b[:n] {
+			b[i] ^= key[pos&3]
+			pos++
+		}
+		b = b[n:]
+	}
+
+	// Create aligned word size key.
+	var k [wordSize]byte
+	for i := range k {
+		k[i] = key[(pos+i)&3]
+	}
+	kw := *(*uintptr)(unsafe.Pointer(&k))
+
+	// Mask one word at a time.
+	n := (len(b) / wordSize) * wordSize
+	for i := 0; i < n; i += wordSize {
+		*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(i))) ^= kw
+	}
+
+	// Mask one byte at a time for remaining bytes.
+	b = b[n:]
+	for i := range b {
+		b[i] ^= key[pos&3]
+		pos++
+	}
+
+	return pos & 3
+}
diff --git a/vendor/github.com/gorilla/websocket/mask_safe.go b/vendor/github.com/gorilla/websocket/mask_safe.go
new file mode 100644
index 00000000000..2aac060e52e
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/mask_safe.go
@@ -0,0 +1,15 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.  Use of
+// this source code is governed by a BSD-style license that can be found in the
+// LICENSE file.
+
+// +build appengine
+
+package websocket
+
+func maskBytes(key [4]byte, pos int, b []byte) int {
+	for i := range b {
+		b[i] ^= key[pos&3]
+		pos++
+	}
+	return pos & 3
+}
diff --git a/vendor/github.com/gorilla/websocket/prepared.go b/vendor/github.com/gorilla/websocket/prepared.go
new file mode 100644
index 00000000000..1efffbd1ebe
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/prepared.go
@@ -0,0 +1,103 @@
+// Copyright 2017 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+	"bytes"
+	"net"
+	"sync"
+	"time"
+)
+
+// PreparedMessage caches on the wire representations of a message payload.
+// Use PreparedMessage to efficiently send a message payload to multiple
+// connections. PreparedMessage is especially useful when compression is used
+// because the CPU and memory expensive compression operation can be executed
+// once for a given set of compression options.
+type PreparedMessage struct {
+	messageType int
+	data        []byte
+	err         error
+	mu          sync.Mutex
+	frames      map[prepareKey]*preparedFrame
+}
+
+// prepareKey defines a unique set of options to cache prepared frames in PreparedMessage.
+type prepareKey struct {
+	isServer         bool
+	compress         bool
+	compressionLevel int
+}
+
+// preparedFrame contains data in wire representation.
+type preparedFrame struct {
+	once sync.Once
+	data []byte
+}
+
+// NewPreparedMessage returns an initialized PreparedMessage. You can then send
+// it to connection using WritePreparedMessage method. Valid wire
+// representation will be calculated lazily only once for a set of current
+// connection options.
+func NewPreparedMessage(messageType int, data []byte) (*PreparedMessage, error) {
+	pm := &PreparedMessage{
+		messageType: messageType,
+		frames:      make(map[prepareKey]*preparedFrame),
+		data:        data,
+	}
+
+	// Prepare a plain server frame.
+	_, frameData, err := pm.frame(prepareKey{isServer: true, compress: false})
+	if err != nil {
+		return nil, err
+	}
+
+	// To protect against caller modifying the data argument, remember the data
+	// copied to the plain server frame.
+	pm.data = frameData[len(frameData)-len(data):]
+	return pm, nil
+}
+
+func (pm *PreparedMessage) frame(key prepareKey) (int, []byte, error) {
+	pm.mu.Lock()
+	frame, ok := pm.frames[key]
+	if !ok {
+		frame = &preparedFrame{}
+		pm.frames[key] = frame
+	}
+	pm.mu.Unlock()
+
+	var err error
+	frame.once.Do(func() {
+		// Prepare a frame using a 'fake' connection.
+		// TODO: Refactor code in conn.go to allow more direct construction of
+		// the frame.
+		mu := make(chan bool, 1)
+		mu <- true
+		var nc prepareConn
+		c := &Conn{
+			conn:                   &nc,
+			mu:                     mu,
+			isServer:               key.isServer,
+			compressionLevel:       key.compressionLevel,
+			enableWriteCompression: true,
+			writeBuf:               make([]byte, defaultWriteBufferSize+maxFrameHeaderSize),
+		}
+		if key.compress {
+			c.newCompressionWriter = compressNoContextTakeover
+		}
+		err = c.WriteMessage(pm.messageType, pm.data)
+		frame.data = nc.buf.Bytes()
+	})
+	return pm.messageType, frame.data, err
+}
+
+type prepareConn struct {
+	buf bytes.Buffer
+	net.Conn
+}
+
+func (pc *prepareConn) Write(p []byte) (int, error)        { return pc.buf.Write(p) }
+func (pc *prepareConn) SetWriteDeadline(t time.Time) error { return nil }
diff --git a/vendor/github.com/gorilla/websocket/server.go b/vendor/github.com/gorilla/websocket/server.go
index e56a004933a..6ae97c54fec 100644
--- a/vendor/github.com/gorilla/websocket/server.go
+++ b/vendor/github.com/gorilla/websocket/server.go
@@ -28,8 +28,9 @@ type Upgrader struct {
 	HandshakeTimeout time.Duration
 
 	// ReadBufferSize and WriteBufferSize specify I/O buffer sizes. If a buffer
-	// size is zero, then a default value of 4096 is used. The I/O buffer sizes
-	// do not limit the size of the messages that can be sent or received.
+	// size is zero, then buffers allocated by the HTTP server are used. The
+	// I/O buffer sizes do not limit the size of the messages that can be sent
+	// or received.
 	ReadBufferSize, WriteBufferSize int
 
 	// Subprotocols specifies the server's supported protocols in order of
@@ -46,6 +47,12 @@ type Upgrader struct {
 	// CheckOrigin is nil, the host in the Origin header must not be set or
 	// must match the host of the request.
 	CheckOrigin func(r *http.Request) bool
+
+	// EnableCompression specify if the server should attempt to negotiate per
+	// message compression (RFC 7692). Setting this value to true does not
+	// guarantee that compression will be supported. Currently only "no context
+	// takeover" modes are supported.
+	EnableCompression bool
 }
 
 func (u *Upgrader) returnError(w http.ResponseWriter, r *http.Request, status int, reason string) (*Conn, error) {
@@ -53,6 +60,7 @@ func (u *Upgrader) returnError(w http.ResponseWriter, r *http.Request, status in
 	if u.Error != nil {
 		u.Error(w, r, status, err)
 	} else {
+		w.Header().Set("Sec-Websocket-Version", "13")
 		http.Error(w, http.StatusText(status), status)
 	}
 	return nil, err
@@ -92,17 +100,28 @@ func (u *Upgrader) selectSubprotocol(r *http.Request, responseHeader http.Header
 // The responseHeader is included in the response to the client's upgrade
 // request. Use the responseHeader to specify cookies (Set-Cookie) and the
 // application negotiated subprotocol (Sec-Websocket-Protocol).
+//
+// If the upgrade fails, then Upgrade replies to the client with an HTTP error
+// response.
 func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header) (*Conn, error) {
-	if values := r.Header["Sec-Websocket-Version"]; len(values) == 0 || values[0] != "13" {
-		return u.returnError(w, r, http.StatusBadRequest, "websocket: version != 13")
+	if r.Method != "GET" {
+		return u.returnError(w, r, http.StatusMethodNotAllowed, "websocket: not a websocket handshake: request method is not GET")
+	}
+
+	if _, ok := responseHeader["Sec-Websocket-Extensions"]; ok {
+		return u.returnError(w, r, http.StatusInternalServerError, "websocket: application specific 'Sec-Websocket-Extensions' headers are unsupported")
 	}
 
 	if !tokenListContainsValue(r.Header, "Connection", "upgrade") {
-		return u.returnError(w, r, http.StatusBadRequest, "websocket: could not find connection header with token 'upgrade'")
+		return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'upgrade' token not found in 'Connection' header")
 	}
 
 	if !tokenListContainsValue(r.Header, "Upgrade", "websocket") {
-		return u.returnError(w, r, http.StatusBadRequest, "websocket: could not find upgrade header with token 'websocket'")
+		return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'websocket' token not found in 'Upgrade' header")
+	}
+
+	if !tokenListContainsValue(r.Header, "Sec-Websocket-Version", "13") {
+		return u.returnError(w, r, http.StatusBadRequest, "websocket: unsupported version: 13 not found in 'Sec-Websocket-Version' header")
 	}
 
 	checkOrigin := u.CheckOrigin
@@ -110,19 +129,30 @@ func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeade
 		checkOrigin = checkSameOrigin
 	}
 	if !checkOrigin(r) {
-		return u.returnError(w, r, http.StatusForbidden, "websocket: origin not allowed")
+		return u.returnError(w, r, http.StatusForbidden, "websocket: 'Origin' header value not allowed")
 	}
 
 	challengeKey := r.Header.Get("Sec-Websocket-Key")
 	if challengeKey == "" {
-		return u.returnError(w, r, http.StatusBadRequest, "websocket: key missing or blank")
+		return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: `Sec-Websocket-Key' header is missing or blank")
 	}
 
 	subprotocol := u.selectSubprotocol(r, responseHeader)
 
+	// Negotiate PMCE
+	var compress bool
+	if u.EnableCompression {
+		for _, ext := range parseExtensions(r.Header) {
+			if ext[""] != "permessage-deflate" {
+				continue
+			}
+			compress = true
+			break
+		}
+	}
+
 	var (
 		netConn net.Conn
-		br      *bufio.Reader
 		err     error
 	)
 
@@ -130,21 +160,25 @@ func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeade
 	if !ok {
 		return u.returnError(w, r, http.StatusInternalServerError, "websocket: response does not implement http.Hijacker")
 	}
-	var rw *bufio.ReadWriter
-	netConn, rw, err = h.Hijack()
+	var brw *bufio.ReadWriter
+	netConn, brw, err = h.Hijack()
 	if err != nil {
 		return u.returnError(w, r, http.StatusInternalServerError, err.Error())
 	}
-	br = rw.Reader
 
-	if br.Buffered() > 0 {
+	if brw.Reader.Buffered() > 0 {
 		netConn.Close()
 		return nil, errors.New("websocket: client sent data before handshake is complete")
 	}
 
-	c := newConn(netConn, true, u.ReadBufferSize, u.WriteBufferSize)
+	c := newConnBRW(netConn, true, u.ReadBufferSize, u.WriteBufferSize, brw)
 	c.subprotocol = subprotocol
 
+	if compress {
+		c.newCompressionWriter = compressNoContextTakeover
+		c.newDecompressionReader = decompressNoContextTakeover
+	}
+
 	p := c.writeBuf[:0]
 	p = append(p, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "...)
 	p = append(p, computeAcceptKey(challengeKey)...)
@@ -154,6 +188,9 @@ func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeade
 		p = append(p, c.subprotocol...)
 		p = append(p, "\r\n"...)
 	}
+	if compress {
+		p = append(p, "Sec-Websocket-Extensions: permessage-deflate; server_no_context_takeover; client_no_context_takeover\r\n"...)
+	}
 	for k, vs := range responseHeader {
 		if k == "Sec-Websocket-Protocol" {
 			continue
@@ -193,10 +230,11 @@ func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeade
 
 // Upgrade upgrades the HTTP server connection to the WebSocket protocol.
 //
-// This function is deprecated, use websocket.Upgrader instead.
+// Deprecated: Use websocket.Upgrader instead.
 //
-// The application is responsible for checking the request origin before
-// calling Upgrade. An example implementation of the same origin policy is:
+// Upgrade does not perform origin checking. The application is responsible for
+// checking the Origin header before calling Upgrade. An example implementation
+// of the same origin policy check is:
 //
 //	if req.Header.Get("Origin") != "http://"+req.Host {
 //		http.Error(w, "Origin not allowed", 403)
@@ -245,3 +283,10 @@ func Subprotocols(r *http.Request) []string {
 	}
 	return protocols
 }
+
+// IsWebSocketUpgrade returns true if the client requested upgrade to the
+// WebSocket protocol.
+func IsWebSocketUpgrade(r *http.Request) bool {
+	return tokenListContainsValue(r.Header, "Connection", "upgrade") &&
+		tokenListContainsValue(r.Header, "Upgrade", "websocket")
+}
diff --git a/vendor/github.com/gorilla/websocket/util.go b/vendor/github.com/gorilla/websocket/util.go
index ffdc265ed78..262e647bce2 100644
--- a/vendor/github.com/gorilla/websocket/util.go
+++ b/vendor/github.com/gorilla/websocket/util.go
@@ -13,19 +13,6 @@ import (
 	"strings"
 )
 
-// tokenListContainsValue returns true if the 1#token header with the given
-// name contains token.
-func tokenListContainsValue(header http.Header, name string, value string) bool {
-	for _, v := range header[name] {
-		for _, s := range strings.Split(v, ",") {
-			if strings.EqualFold(value, strings.TrimSpace(s)) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
 var keyGUID = []byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
 
 func computeAcceptKey(challengeKey string) string {
@@ -42,3 +29,186 @@ func generateChallengeKey() (string, error) {
 	}
 	return base64.StdEncoding.EncodeToString(p), nil
 }
+
+// Octet types from RFC 2616.
+var octetTypes [256]byte
+
+const (
+	isTokenOctet = 1 << iota
+	isSpaceOctet
+)
+
+func init() {
+	// From RFC 2616
+	//
+	// OCTET      = <any 8-bit sequence of data>
+	// CHAR       = <any US-ASCII character (octets 0 - 127)>
+	// CTL        = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
+	// CR         = <US-ASCII CR, carriage return (13)>
+	// LF         = <US-ASCII LF, linefeed (10)>
+	// SP         = <US-ASCII SP, space (32)>
+	// HT         = <US-ASCII HT, horizontal-tab (9)>
+	// <">        = <US-ASCII double-quote mark (34)>
+	// CRLF       = CR LF
+	// LWS        = [CRLF] 1*( SP | HT )
+	// TEXT       = <any OCTET except CTLs, but including LWS>
+	// separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <">
+	//              | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT
+	// token      = 1*<any CHAR except CTLs or separators>
+	// qdtext     = <any TEXT except <">>
+
+	for c := 0; c < 256; c++ {
+		var t byte
+		isCtl := c <= 31 || c == 127
+		isChar := 0 <= c && c <= 127
+		isSeparator := strings.IndexRune(" \t\"(),/:;<=>?@[]\\{}", rune(c)) >= 0
+		if strings.IndexRune(" \t\r\n", rune(c)) >= 0 {
+			t |= isSpaceOctet
+		}
+		if isChar && !isCtl && !isSeparator {
+			t |= isTokenOctet
+		}
+		octetTypes[c] = t
+	}
+}
+
+func skipSpace(s string) (rest string) {
+	i := 0
+	for ; i < len(s); i++ {
+		if octetTypes[s[i]]&isSpaceOctet == 0 {
+			break
+		}
+	}
+	return s[i:]
+}
+
+func nextToken(s string) (token, rest string) {
+	i := 0
+	for ; i < len(s); i++ {
+		if octetTypes[s[i]]&isTokenOctet == 0 {
+			break
+		}
+	}
+	return s[:i], s[i:]
+}
+
+func nextTokenOrQuoted(s string) (value string, rest string) {
+	if !strings.HasPrefix(s, "\"") {
+		return nextToken(s)
+	}
+	s = s[1:]
+	for i := 0; i < len(s); i++ {
+		switch s[i] {
+		case '"':
+			return s[:i], s[i+1:]
+		case '\\':
+			p := make([]byte, len(s)-1)
+			j := copy(p, s[:i])
+			escape := true
+			for i = i + 1; i < len(s); i++ {
+				b := s[i]
+				switch {
+				case escape:
+					escape = false
+					p[j] = b
+					j++
+				case b == '\\':
+					escape = true
+				case b == '"':
+					return string(p[:j]), s[i+1:]
+				default:
+					p[j] = b
+					j++
+				}
+			}
+			return "", ""
+		}
+	}
+	return "", ""
+}
+
+// tokenListContainsValue returns true if the 1#token header with the given
+// name contains token.
+func tokenListContainsValue(header http.Header, name string, value string) bool {
+headers:
+	for _, s := range header[name] {
+		for {
+			var t string
+			t, s = nextToken(skipSpace(s))
+			if t == "" {
+				continue headers
+			}
+			s = skipSpace(s)
+			if s != "" && s[0] != ',' {
+				continue headers
+			}
+			if strings.EqualFold(t, value) {
+				return true
+			}
+			if s == "" {
+				continue headers
+			}
+			s = s[1:]
+		}
+	}
+	return false
+}
+
+// parseExtensiosn parses WebSocket extensions from a header.
+func parseExtensions(header http.Header) []map[string]string {
+
+	// From RFC 6455:
+	//
+	//  Sec-WebSocket-Extensions = extension-list
+	//  extension-list = 1#extension
+	//  extension = extension-token *( ";" extension-param )
+	//  extension-token = registered-token
+	//  registered-token = token
+	//  extension-param = token [ "=" (token | quoted-string) ]
+	//     ;When using the quoted-string syntax variant, the value
+	//     ;after quoted-string unescaping MUST conform to the
+	//     ;'token' ABNF.
+
+	var result []map[string]string
+headers:
+	for _, s := range header["Sec-Websocket-Extensions"] {
+		for {
+			var t string
+			t, s = nextToken(skipSpace(s))
+			if t == "" {
+				continue headers
+			}
+			ext := map[string]string{"": t}
+			for {
+				s = skipSpace(s)
+				if !strings.HasPrefix(s, ";") {
+					break
+				}
+				var k string
+				k, s = nextToken(skipSpace(s[1:]))
+				if k == "" {
+					continue headers
+				}
+				s = skipSpace(s)
+				var v string
+				if strings.HasPrefix(s, "=") {
+					v, s = nextTokenOrQuoted(skipSpace(s[1:]))
+					s = skipSpace(s)
+				}
+				if s != "" && s[0] != ',' && s[0] != ';' {
+					continue headers
+				}
+				ext[k] = v
+			}
+			if s != "" && s[0] != ',' {
+				continue headers
+			}
+			result = append(result, ext)
+			if s == "" {
+				continue headers
+			}
+			s = s[1:]
+		}
+	}
+	return result
+}
diff --git a/vendor/github.com/cockroachdb/cmux/.gitignore b/vendor/github.com/soheilhy/cmux/.gitignore
similarity index 100%
rename from vendor/github.com/cockroachdb/cmux/.gitignore
rename to vendor/github.com/soheilhy/cmux/.gitignore
diff --git a/vendor/github.com/soheilhy/cmux/.travis.yml b/vendor/github.com/soheilhy/cmux/.travis.yml
new file mode 100644
index 00000000000..4bc48e0669c
--- /dev/null
+++ b/vendor/github.com/soheilhy/cmux/.travis.yml
@@ -0,0 +1,29 @@
+language: go
+
+go:
+  - 1.6
+  - 1.7
+  - 1.8
+  - tip
+
+matrix:
+  allow_failures:
+    - go: tip
+
+gobuild_args: -race
+
+before_install:
+  - if [[ $TRAVIS_GO_VERSION == 1.6* ]]; then go get -u github.com/kisielk/errcheck; fi
+  - if [[ $TRAVIS_GO_VERSION == 1.6* ]]; then go get -u github.com/golang/lint/golint; fi
+
+before_script:
+  - '! gofmt -s -l . | read'
+  - echo $TRAVIS_GO_VERSION
+  - if [[ $TRAVIS_GO_VERSION == 1.6* ]]; then golint ./...; fi
+  - if [[ $TRAVIS_GO_VERSION == 1.6* ]]; then errcheck ./...; fi
+  - if [[ $TRAVIS_GO_VERSION == 1.6* ]]; then go tool vet .; fi
+  - if [[ $TRAVIS_GO_VERSION == 1.6* ]]; then go tool vet --shadow .; fi
+
+script:
+  - go test -bench . -v ./...
+  - go test -race -bench . -v ./...
diff --git a/vendor/github.com/cockroachdb/cmux/BUILD b/vendor/github.com/soheilhy/cmux/BUILD
similarity index 83%
rename from vendor/github.com/cockroachdb/cmux/BUILD
rename to vendor/github.com/soheilhy/cmux/BUILD
index 050aa8dcdcf..3b5d786c99f 100644
--- a/vendor/github.com/cockroachdb/cmux/BUILD
+++ b/vendor/github.com/soheilhy/cmux/BUILD
@@ -5,11 +5,12 @@ go_library(
     srcs = [
         "buffer.go",
         "cmux.go",
+        "doc.go",
         "matchers.go",
         "patricia.go",
     ],
-    importmap = "k8s.io/kubernetes/vendor/github.com/cockroachdb/cmux",
-    importpath = "github.com/cockroachdb/cmux",
+    importmap = "k8s.io/kubernetes/vendor/github.com/soheilhy/cmux",
+    importpath = "github.com/soheilhy/cmux",
     visibility = ["//visibility:public"],
     deps = [
         "//vendor/golang.org/x/net/http2:go_default_library",
diff --git a/vendor/github.com/soheilhy/cmux/CONTRIBUTORS b/vendor/github.com/soheilhy/cmux/CONTRIBUTORS
new file mode 100644
index 00000000000..49878f228a1
--- /dev/null
+++ b/vendor/github.com/soheilhy/cmux/CONTRIBUTORS
@@ -0,0 +1,12 @@
+# The list of people who have contributed code to the cmux repository.
+#
+# Auto-generated with:
+#		git log --oneline --pretty=format:'%an <%aE>' | sort -u
+#
+Andreas Jaekle <andreas@jaekle.net>
+Dmitri Shuralyov <shurcooL@gmail.com>
+Ethan Mosbaugh <emosbaugh@gmail.com>
+Soheil Hassas Yeganeh <soheil.h.y@gmail.com>
+Soheil Hassas Yeganeh <soheil@cs.toronto.edu>
+Tamir Duberstein <tamir@cockroachlabs.com>
+Tamir Duberstein <tamird@gmail.com>
diff --git a/vendor/github.com/cockroachdb/cmux/LICENSE b/vendor/github.com/soheilhy/cmux/LICENSE
similarity index 100%
rename from vendor/github.com/cockroachdb/cmux/LICENSE
rename to vendor/github.com/soheilhy/cmux/LICENSE
diff --git a/vendor/github.com/soheilhy/cmux/README.md b/vendor/github.com/soheilhy/cmux/README.md
new file mode 100644
index 00000000000..70306e6ab62
--- /dev/null
+++ b/vendor/github.com/soheilhy/cmux/README.md
@@ -0,0 +1,83 @@
+# cmux: Connection Mux ![Travis Build Status](https://api.travis-ci.org/soheilhy/args.svg?branch=master "Travis Build Status") [![GoDoc](https://godoc.org/github.com/soheilhy/cmux?status.svg)](http://godoc.org/github.com/soheilhy/cmux)
+
+cmux is a generic Go library to multiplex connections based on
+their payload. Using cmux, you can serve gRPC, SSH, HTTPS, HTTP,
+Go RPC, and pretty much any other protocol on the same TCP listener.
+
+## How-To
+Simply create your main listener, create a cmux for that listener,
+and then match connections:
+```go
+// Create the main listener.
+l, err := net.Listen("tcp", ":23456")
+if err != nil {
+	log.Fatal(err)
+}
+
+// Create a cmux.
+m := cmux.New(l)
+
+// Match connections in order:
+// First grpc, then HTTP, and otherwise Go RPC/TCP.
+grpcL := m.Match(cmux.HTTP2HeaderField("content-type", "application/grpc"))
+httpL := m.Match(cmux.HTTP1Fast())
+trpcL := m.Match(cmux.Any()) // Any means anything that is not yet matched.
+
+// Create your protocol servers.
+grpcS := grpc.NewServer()
+grpchello.RegisterGreeterServer(grpcs, &server{})
+
+httpS := &http.Server{
+	Handler: &helloHTTP1Handler{},
+}
+
+trpcS := rpc.NewServer()
+trpcS.Register(&ExampleRPCRcvr{})
+
+// Use the muxed listeners for your servers.
+go grpcS.Serve(grpcL)
+go httpS.Serve(httpL)
+go trpcS.Accept(trpcL)
+
+// Start serving!
+m.Serve()
+```
+
+Take a look at [other examples in the GoDoc](http://godoc.org/github.com/soheilhy/cmux/#pkg-examples).
+
+## Docs
+* [GoDocs](https://godoc.org/github.com/soheilhy/cmux)
+
+## Performance
+There is room for improvment but, since we are only matching
+the very first bytes of a connection, the performance overheads on
+long-lived connections (i.e., RPCs and pipelined HTTP streams)
+is negligible.
+
+*TODO(soheil)*: Add benchmarks.
+
+## Limitations
+* *TLS*: `net/http` uses a type assertion to identify TLS connections; since
+cmux's lookahead-implementing connection wraps the underlying TLS connection,
+this type assertion fails.
+Because of that, you can serve HTTPS using cmux but `http.Request.TLS`
+would not be set in your handlers.
+
+* *Different Protocols on The Same Connection*: `cmux` matches the connection
+when it's accepted. For example, one connection can be either gRPC or REST, but
+not both. That is, we assume that a client connection is either used for gRPC
+or REST.
+
+* *Java gRPC Clients*: Java gRPC client blocks until it receives a SETTINGS
+frame from the server. If you are using the Java client to connect to a cmux'ed
+gRPC server please match with writers:
+```go
+grpcl := m.MatchWithWriters(cmux.HTTP2MatchHeaderFieldSendSettings("content-type", "application/grpc"))
+```
+
+# Copyright and License
+Copyright 2016 The CMux Authors. All rights reserved.
+
+See [CONTRIBUTORS](https://github.com/soheilhy/cmux/blob/master/CONTRIBUTORS)
+for the CMux Authors. Code is released under
+[the Apache 2 license](https://github.com/soheilhy/cmux/blob/master/LICENSE).
diff --git a/vendor/github.com/soheilhy/cmux/buffer.go b/vendor/github.com/soheilhy/cmux/buffer.go
new file mode 100644
index 00000000000..f8cf30a1e66
--- /dev/null
+++ b/vendor/github.com/soheilhy/cmux/buffer.go
@@ -0,0 +1,67 @@
+// Copyright 2016 The CMux Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+// implied. See the License for the specific language governing
+// permissions and limitations under the License.
+
+package cmux
+
+import (
+	"bytes"
+	"io"
+)
+
+// bufferedReader is an optimized implementation of io.Reader that behaves like
+// ```
+// io.MultiReader(bytes.NewReader(buffer.Bytes()), io.TeeReader(source, buffer))
+// ```
+// without allocating.
+type bufferedReader struct {
+	source     io.Reader
+	buffer     bytes.Buffer
+	bufferRead int
+	bufferSize int
+	sniffing   bool
+	lastErr    error
+}
+
+func (s *bufferedReader) Read(p []byte) (int, error) {
+	if s.bufferSize > s.bufferRead {
+		// If we have already read something from the buffer before, we return the
+		// same data and the last error if any. We need to immediately return,
+		// otherwise we may block for ever, if we try to be smart and call
+		// source.Read() seeking a little bit of more data.
+		bn := copy(p, s.buffer.Bytes()[s.bufferRead:s.bufferSize])
+		s.bufferRead += bn
+		return bn, s.lastErr
+	} else if !s.sniffing && s.buffer.Cap() != 0 {
+		// We don't need the buffer anymore.
+		// Reset it to release the internal slice.
+		s.buffer = bytes.Buffer{}
+	}
+
+	// If there is nothing more to return in the sniffed buffer, read from the
+	// source.
+	sn, sErr := s.source.Read(p)
+	if sn > 0 && s.sniffing {
+		s.lastErr = sErr
+		if wn, wErr := s.buffer.Write(p[:sn]); wErr != nil {
+			return wn, wErr
+		}
+	}
+	return sn, sErr
+}
+
+func (s *bufferedReader) reset(snif bool) {
+	s.sniffing = snif
+	s.bufferRead = 0
+	s.bufferSize = s.buffer.Len()
+}
diff --git a/vendor/github.com/cockroachdb/cmux/cmux.go b/vendor/github.com/soheilhy/cmux/cmux.go
similarity index 62%
rename from vendor/github.com/cockroachdb/cmux/cmux.go
rename to vendor/github.com/soheilhy/cmux/cmux.go
index 89cc910b024..9de6b0a3c2a 100644
--- a/vendor/github.com/cockroachdb/cmux/cmux.go
+++ b/vendor/github.com/soheilhy/cmux/cmux.go
@@ -1,16 +1,33 @@
+// Copyright 2016 The CMux Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+// implied. See the License for the specific language governing
+// permissions and limitations under the License.
+
 package cmux
 
 import (
-	"bytes"
 	"fmt"
 	"io"
 	"net"
 	"sync"
+	"time"
 )
 
 // Matcher matches a connection based on its content.
 type Matcher func(io.Reader) bool
 
+// MatchWriter is a match that can also write response (say to do handshake).
+type MatchWriter func(io.Writer, io.Reader) bool
+
 // ErrorHandler handles an error and returns whether
 // the mux should continue serving the listener.
 type ErrorHandler func(error) bool
@@ -44,13 +61,17 @@ func (e errListenerClosed) Timeout() bool   { return false }
 // listener is closed.
 var ErrListenerClosed = errListenerClosed("mux: listener closed")
 
+// for readability of readTimeout
+var noTimeout time.Duration
+
 // New instantiates a new connection multiplexer.
 func New(l net.Listener) CMux {
 	return &cMux{
-		root:   l,
-		bufLen: 1024,
-		errh:   func(_ error) bool { return true },
-		donec:  make(chan struct{}),
+		root:        l,
+		bufLen:      1024,
+		errh:        func(_ error) bool { return true },
+		donec:       make(chan struct{}),
+		readTimeout: noTimeout,
 	}
 }
 
@@ -61,27 +82,53 @@ type CMux interface {
 	//
 	// The order used to call Match determines the priority of matchers.
 	Match(...Matcher) net.Listener
+	// MatchWithWriters returns a net.Listener that accepts only the
+	// connections that matched by at least of the matcher writers.
+	//
+	// Prefer Matchers over MatchWriters, since the latter can write on the
+	// connection before the actual handler.
+	//
+	// The order used to call Match determines the priority of matchers.
+	MatchWithWriters(...MatchWriter) net.Listener
 	// Serve starts multiplexing the listener. Serve blocks and perhaps
 	// should be invoked concurrently within a go routine.
 	Serve() error
 	// HandleError registers an error handler that handles listener errors.
 	HandleError(ErrorHandler)
+	// sets a timeout for the read of matchers
+	SetReadTimeout(time.Duration)
 }
 
 type matchersListener struct {
-	ss []Matcher
+	ss []MatchWriter
 	l  muxListener
 }
 
 type cMux struct {
-	root   net.Listener
-	bufLen int
-	errh   ErrorHandler
-	donec  chan struct{}
-	sls    []matchersListener
+	root        net.Listener
+	bufLen      int
+	errh        ErrorHandler
+	donec       chan struct{}
+	sls         []matchersListener
+	readTimeout time.Duration
+}
+
+func matchersToMatchWriters(matchers []Matcher) []MatchWriter {
+	mws := make([]MatchWriter, 0, len(matchers))
+	for _, m := range matchers {
+		mws = append(mws, func(w io.Writer, r io.Reader) bool {
+			return m(r)
+		})
+	}
+	return mws
 }
 
 func (m *cMux) Match(matchers ...Matcher) net.Listener {
+	mws := matchersToMatchWriters(matchers)
+	return m.MatchWithWriters(mws...)
+}
+
+func (m *cMux) MatchWithWriters(matchers ...MatchWriter) net.Listener {
 	ml := muxListener{
 		Listener: m.root,
 		connc:    make(chan net.Conn, m.bufLen),
@@ -90,6 +137,10 @@ func (m *cMux) Match(matchers ...Matcher) net.Listener {
 	return ml
 }
 
+func (m *cMux) SetReadTimeout(t time.Duration) {
+	m.readTimeout = t
+}
+
 func (m *cMux) Serve() error {
 	var wg sync.WaitGroup
 
@@ -124,10 +175,17 @@ func (m *cMux) serve(c net.Conn, donec <-chan struct{}, wg *sync.WaitGroup) {
 	defer wg.Done()
 
 	muc := newMuxConn(c)
+	if m.readTimeout > noTimeout {
+		_ = c.SetReadDeadline(time.Now().Add(m.readTimeout))
+	}
 	for _, sl := range m.sls {
 		for _, s := range sl.ss {
-			matched := s(muc.getSniffer())
+			matched := s(muc.Conn, muc.startSniffing())
 			if matched {
+				muc.doneSniffing()
+				if m.readTimeout > noTimeout {
+					_ = c.SetReadDeadline(time.Time{})
+				}
 				select {
 				case sl.l.connc <- muc:
 				case <-donec:
@@ -177,13 +235,13 @@ func (l muxListener) Accept() (net.Conn, error) {
 // MuxConn wraps a net.Conn and provides transparent sniffing of connection data.
 type MuxConn struct {
 	net.Conn
-	buf     bytes.Buffer
-	sniffer bufferedReader
+	buf bufferedReader
 }
 
 func newMuxConn(c net.Conn) *MuxConn {
 	return &MuxConn{
 		Conn: c,
+		buf:  bufferedReader{source: c},
 	}
 }
 
@@ -198,13 +256,14 @@ func newMuxConn(c net.Conn) *MuxConn {
 // return either err == EOF or err == nil.  The next Read should
 // return 0, EOF.
 func (m *MuxConn) Read(p []byte) (int, error) {
-	if n, err := m.buf.Read(p); err != io.EOF {
-		return n, err
-	}
-	return m.Conn.Read(p)
+	return m.buf.Read(p)
 }
 
-func (m *MuxConn) getSniffer() io.Reader {
-	m.sniffer = bufferedReader{source: m.Conn, buffer: &m.buf, bufferSize: m.buf.Len()}
-	return &m.sniffer
+func (m *MuxConn) startSniffing() io.Reader {
+	m.buf.reset(true)
+	return &m.buf
+}
+
+func (m *MuxConn) doneSniffing() {
+	m.buf.reset(false)
 }
diff --git a/vendor/github.com/soheilhy/cmux/doc.go b/vendor/github.com/soheilhy/cmux/doc.go
new file mode 100644
index 00000000000..aaa8f315899
--- /dev/null
+++ b/vendor/github.com/soheilhy/cmux/doc.go
@@ -0,0 +1,18 @@
+// Copyright 2016 The CMux Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+// implied. See the License for the specific language governing
+// permissions and limitations under the License.
+
+// Package cmux is a library to multiplex network connections based on
+// their payload. Using cmux, you can serve different protocols from the
+// same listener.
+package cmux
diff --git a/vendor/github.com/soheilhy/cmux/matchers.go b/vendor/github.com/soheilhy/cmux/matchers.go
new file mode 100644
index 00000000000..652fd869178
--- /dev/null
+++ b/vendor/github.com/soheilhy/cmux/matchers.go
@@ -0,0 +1,262 @@
+// Copyright 2016 The CMux Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+// implied. See the License for the specific language governing
+// permissions and limitations under the License.
+
+package cmux
+
+import (
+	"bufio"
+	"crypto/tls"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strings"
+
+	"golang.org/x/net/http2"
+	"golang.org/x/net/http2/hpack"
+)
+
+// Any is a Matcher that matches any connection.
+func Any() Matcher {
+	return func(r io.Reader) bool { return true }
+}
+
+// PrefixMatcher returns a matcher that matches a connection if it
+// starts with any of the strings in strs.
+func PrefixMatcher(strs ...string) Matcher {
+	pt := newPatriciaTreeString(strs...)
+	return pt.matchPrefix
+}
+
+func prefixByteMatcher(list ...[]byte) Matcher {
+	pt := newPatriciaTree(list...)
+	return pt.matchPrefix
+}
+
+var defaultHTTPMethods = []string{
+	"OPTIONS",
+	"GET",
+	"HEAD",
+	"POST",
+	"PUT",
+	"DELETE",
+	"TRACE",
+	"CONNECT",
+}
+
+// HTTP1Fast only matches the methods in the HTTP request.
+//
+// This matcher is very optimistic: if it returns true, it does not mean that
+// the request is a valid HTTP response. If you want a correct but slower HTTP1
+// matcher, use HTTP1 instead.
+func HTTP1Fast(extMethods ...string) Matcher {
+	return PrefixMatcher(append(defaultHTTPMethods, extMethods...)...)
+}
+
+// TLS matches HTTPS requests.
+//
+// By default, any TLS handshake packet is matched. An optional whitelist
+// of versions can be passed in to restrict the matcher, for example:
+//  TLS(tls.VersionTLS11, tls.VersionTLS12)
+func TLS(versions ...int) Matcher {
+	if len(versions) == 0 {
+		versions = []int{
+			tls.VersionSSL30,
+			tls.VersionTLS10,
+			tls.VersionTLS11,
+			tls.VersionTLS12,
+		}
+	}
+	prefixes := [][]byte{}
+	for _, v := range versions {
+		prefixes = append(prefixes, []byte{22, byte(v >> 8 & 0xff), byte(v & 0xff)})
+	}
+	return prefixByteMatcher(prefixes...)
+}
+
+const maxHTTPRead = 4096
+
+// HTTP1 parses the first line or upto 4096 bytes of the request to see if
+// the conection contains an HTTP request.
+func HTTP1() Matcher {
+	return func(r io.Reader) bool {
+		br := bufio.NewReader(&io.LimitedReader{R: r, N: maxHTTPRead})
+		l, part, err := br.ReadLine()
+		if err != nil || part {
+			return false
+		}
+
+		_, _, proto, ok := parseRequestLine(string(l))
+		if !ok {
+			return false
+		}
+
+		v, _, ok := http.ParseHTTPVersion(proto)
+		return ok && v == 1
+	}
+}
+
+// grabbed from net/http.
+func parseRequestLine(line string) (method, uri, proto string, ok bool) {
+	s1 := strings.Index(line, " ")
+	s2 := strings.Index(line[s1+1:], " ")
+	if s1 < 0 || s2 < 0 {
+		return
+	}
+	s2 += s1 + 1
+	return line[:s1], line[s1+1 : s2], line[s2+1:], true
+}
+
+// HTTP2 parses the frame header of the first frame to detect whether the
+// connection is an HTTP2 connection.
+func HTTP2() Matcher {
+	return hasHTTP2Preface
+}
+
+// HTTP1HeaderField returns a matcher matching the header fields of the first
+// request of an HTTP 1 connection.
+func HTTP1HeaderField(name, value string) Matcher {
+	return func(r io.Reader) bool {
+		return matchHTTP1Field(r, name, func(gotValue string) bool {
+			return gotValue == value
+		})
+	}
+}
+
+// HTTP1HeaderFieldPrefix returns a matcher matching the header fields of the
+// first request of an HTTP 1 connection. If the header with key name has a
+// value prefixed with valuePrefix, this will match.
+func HTTP1HeaderFieldPrefix(name, valuePrefix string) Matcher {
+	return func(r io.Reader) bool {
+		return matchHTTP1Field(r, name, func(gotValue string) bool {
+			return strings.HasPrefix(gotValue, valuePrefix)
+		})
+	}
+}
+
+// HTTP2HeaderField returns a matcher matching the header fields of the first
+// headers frame.
+func HTTP2HeaderField(name, value string) Matcher {
+	return func(r io.Reader) bool {
+		return matchHTTP2Field(ioutil.Discard, r, name, func(gotValue string) bool {
+			return gotValue == value
+		})
+	}
+}
+
+// HTTP2HeaderFieldPrefix returns a matcher matching the header fields of the
+// first headers frame. If the header with key name has a value prefixed with
+// valuePrefix, this will match.
+func HTTP2HeaderFieldPrefix(name, valuePrefix string) Matcher {
+	return func(r io.Reader) bool {
+		return matchHTTP2Field(ioutil.Discard, r, name, func(gotValue string) bool {
+			return strings.HasPrefix(gotValue, valuePrefix)
+		})
+	}
+}
+
+// HTTP2MatchHeaderFieldSendSettings matches the header field and writes the
+// settings to the server. Prefer HTTP2HeaderField over this one, if the client
+// does not block on receiving a SETTING frame.
+func HTTP2MatchHeaderFieldSendSettings(name, value string) MatchWriter {
+	return func(w io.Writer, r io.Reader) bool {
+		return matchHTTP2Field(w, r, name, func(gotValue string) bool {
+			return gotValue == value
+		})
+	}
+}
+
+// HTTP2MatchHeaderFieldPrefixSendSettings matches the header field prefix
+// and writes the settings to the server. Prefer HTTP2HeaderFieldPrefix over
+// this one, if the client does not block on receiving a SETTING frame.
+func HTTP2MatchHeaderFieldPrefixSendSettings(name, valuePrefix string) MatchWriter {
+	return func(w io.Writer, r io.Reader) bool {
+		return matchHTTP2Field(w, r, name, func(gotValue string) bool {
+			return strings.HasPrefix(gotValue, valuePrefix)
+		})
+	}
+}
+
+func hasHTTP2Preface(r io.Reader) bool {
+	var b [len(http2.ClientPreface)]byte
+	last := 0
+
+	for {
+		n, err := r.Read(b[last:])
+		if err != nil {
+			return false
+		}
+
+		last += n
+		eq := string(b[:last]) == http2.ClientPreface[:last]
+		if last == len(http2.ClientPreface) {
+			return eq
+		}
+		if !eq {
+			return false
+		}
+	}
+}
+
+func matchHTTP1Field(r io.Reader, name string, matches func(string) bool) (matched bool) {
+	req, err := http.ReadRequest(bufio.NewReader(r))
+	if err != nil {
+		return false
+	}
+
+	return matches(req.Header.Get(name))
+}
+
+func matchHTTP2Field(w io.Writer, r io.Reader, name string, matches func(string) bool) (matched bool) {
+	if !hasHTTP2Preface(r) {
+		return false
+	}
+
+	done := false
+	framer := http2.NewFramer(w, r)
+	hdec := hpack.NewDecoder(uint32(4<<10), func(hf hpack.HeaderField) {
+		if hf.Name == name {
+			done = true
+			if matches(hf.Value) {
+				matched = true
+			}
+		}
+	})
+	for {
+		f, err := framer.ReadFrame()
+		if err != nil {
+			return false
+		}
+
+		switch f := f.(type) {
+		case *http2.SettingsFrame:
+			if err := framer.WriteSettings(); err != nil {
+				return false
+			}
+		case *http2.ContinuationFrame:
+			if _, err := hdec.Write(f.HeaderBlockFragment()); err != nil {
+				return false
+			}
+			done = done || f.FrameHeader.Flags&http2.FlagHeadersEndHeaders != 0
+		case *http2.HeadersFrame:
+			if _, err := hdec.Write(f.HeaderBlockFragment()); err != nil {
+				return false
+			}
+			done = done || f.FrameHeader.Flags&http2.FlagHeadersEndHeaders != 0
+		}
+
+		if done {
+			return matched
+		}
+	}
+}
diff --git a/vendor/github.com/cockroachdb/cmux/patricia.go b/vendor/github.com/soheilhy/cmux/patricia.go
similarity index 55%
rename from vendor/github.com/cockroachdb/cmux/patricia.go
rename to vendor/github.com/soheilhy/cmux/patricia.go
index 56ec4e7b287..c3e3d85bdea 100644
--- a/vendor/github.com/cockroachdb/cmux/patricia.go
+++ b/vendor/github.com/soheilhy/cmux/patricia.go
@@ -1,3 +1,17 @@
+// Copyright 2016 The CMux Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+// implied. See the License for the specific language governing
+// permissions and limitations under the License.
+
 package cmux
 
 import (
@@ -8,12 +22,20 @@ import (
 // patriciaTree is a simple patricia tree that handles []byte instead of string
 // and cannot be changed after instantiation.
 type patriciaTree struct {
-	root *ptNode
+	root     *ptNode
+	maxDepth int // max depth of the tree.
 }
 
-func newPatriciaTree(b ...[]byte) *patriciaTree {
+func newPatriciaTree(bs ...[]byte) *patriciaTree {
+	max := 0
+	for _, b := range bs {
+		if max < len(b) {
+			max = len(b)
+		}
+	}
 	return &patriciaTree{
-		root: newNode(b),
+		root:     newNode(bs),
+		maxDepth: max + 1,
 	}
 }
 
@@ -22,17 +44,19 @@ func newPatriciaTreeString(strs ...string) *patriciaTree {
 	for i, s := range strs {
 		b[i] = []byte(s)
 	}
-	return &patriciaTree{
-		root: newNode(b),
-	}
+	return newPatriciaTree(b...)
 }
 
 func (t *patriciaTree) matchPrefix(r io.Reader) bool {
-	return t.root.match(r, true)
+	buf := make([]byte, t.maxDepth)
+	n, _ := io.ReadFull(r, buf)
+	return t.root.match(buf[:n], true)
 }
 
 func (t *patriciaTree) match(r io.Reader) bool {
-	return t.root.match(r, false)
+	buf := make([]byte, t.maxDepth)
+	n, _ := io.ReadFull(r, buf)
+	return t.root.match(buf[:n], false)
 }
 
 type ptNode struct {
@@ -122,52 +146,34 @@ func splitPrefix(bss [][]byte) (prefix []byte, rest [][]byte) {
 	return prefix, rest
 }
 
-func readBytes(r io.Reader, n int) (b []byte, err error) {
-	b = make([]byte, n)
-	o := 0
-	for o < n {
-		nr, err := r.Read(b[o:])
-		if err != nil && err != io.EOF {
-			return b, err
+func (n *ptNode) match(b []byte, prefix bool) bool {
+	l := len(n.prefix)
+	if l > 0 {
+		if l > len(b) {
+			l = len(b)
 		}
-
-		o += nr
-
-		if err == io.EOF {
-			break
-		}
-	}
-	return b[:o], nil
-}
-
-func (n *ptNode) match(r io.Reader, prefix bool) bool {
-	if l := len(n.prefix); l > 0 {
-		b, err := readBytes(r, l)
-		if err != nil || len(b) != l || !bytes.Equal(b, n.prefix) {
+		if !bytes.Equal(b[:l], n.prefix) {
 			return false
 		}
 	}
 
-	if prefix && n.terminal {
+	if n.terminal && (prefix || len(n.prefix) == len(b)) {
 		return true
 	}
 
-	b := make([]byte, 1)
-	for {
-		nr, err := r.Read(b)
-		if nr != 0 {
-			break
-		}
-
-		if err == io.EOF {
-			return n.terminal
-		}
-
-		if err != nil {
-			return false
-		}
+	if l >= len(b) {
+		return false
 	}
 
-	nextN, ok := n.next[b[0]]
-	return ok && nextN.match(r, prefix)
+	nextN, ok := n.next[b[l]]
+	if !ok {
+		return false
+	}
+
+	if l == len(b) {
+		b = b[l:l]
+	} else {
+		b = b[l+1:]
+	}
+	return nextN.match(b, prefix)
 }
diff --git a/vendor/github.com/tmc/grpc-websocket-proxy/LICENSE b/vendor/github.com/tmc/grpc-websocket-proxy/LICENSE
new file mode 100644
index 00000000000..95d0bc81f18
--- /dev/null
+++ b/vendor/github.com/tmc/grpc-websocket-proxy/LICENSE
@@ -0,0 +1,7 @@
+Copyright (C) 2016 Travis Cline
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/BUILD b/vendor/github.com/tmc/grpc-websocket-proxy/wsproxy/BUILD
similarity index 53%
rename from vendor/google.golang.org/genproto/googleapis/api/annotations/BUILD
rename to vendor/github.com/tmc/grpc-websocket-proxy/wsproxy/BUILD
index e3464d0363b..452ce98a424 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/annotations/BUILD
+++ b/vendor/github.com/tmc/grpc-websocket-proxy/wsproxy/BUILD
@@ -3,15 +3,16 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     srcs = [
-        "annotations.pb.go",
-        "http.pb.go",
+        "doc.go",
+        "websocket_proxy.go",
     ],
-    importmap = "k8s.io/kubernetes/vendor/google.golang.org/genproto/googleapis/api/annotations",
-    importpath = "google.golang.org/genproto/googleapis/api/annotations",
+    importmap = "k8s.io/kubernetes/vendor/github.com/tmc/grpc-websocket-proxy/wsproxy",
+    importpath = "github.com/tmc/grpc-websocket-proxy/wsproxy",
     visibility = ["//visibility:public"],
     deps = [
-        "//vendor/github.com/golang/protobuf/proto:go_default_library",
-        "//vendor/github.com/golang/protobuf/protoc-gen-go/descriptor:go_default_library",
+        "//vendor/github.com/gorilla/websocket:go_default_library",
+        "//vendor/github.com/sirupsen/logrus:go_default_library",
+        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 
diff --git a/vendor/github.com/tmc/grpc-websocket-proxy/wsproxy/doc.go b/vendor/github.com/tmc/grpc-websocket-proxy/wsproxy/doc.go
new file mode 100644
index 00000000000..baf9545e288
--- /dev/null
+++ b/vendor/github.com/tmc/grpc-websocket-proxy/wsproxy/doc.go
@@ -0,0 +1,2 @@
+// Package wsproxy implements a websocket proxy for grpc-gateway backed services
+package wsproxy
diff --git a/vendor/github.com/tmc/grpc-websocket-proxy/wsproxy/websocket_proxy.go b/vendor/github.com/tmc/grpc-websocket-proxy/wsproxy/websocket_proxy.go
new file mode 100644
index 00000000000..0fca05a008a
--- /dev/null
+++ b/vendor/github.com/tmc/grpc-websocket-proxy/wsproxy/websocket_proxy.go
@@ -0,0 +1,254 @@
+package wsproxy
+
+import (
+	"bufio"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/gorilla/websocket"
+	"github.com/sirupsen/logrus"
+	"golang.org/x/net/context"
+)
+
+// MethodOverrideParam defines the special URL parameter that is translated into the subsequent proxied streaming http request's method.
+//
+// Deprecated: it is preferable to use the Options parameters to WebSocketProxy to supply parameters.
+var MethodOverrideParam = "method"
+
+// TokenCookieName defines the cookie name that is translated to an 'Authorization: Bearer' header in the streaming http request's headers.
+//
+// Deprecated: it is preferable to use the Options parameters to WebSocketProxy to supply parameters.
+var TokenCookieName = "token"
+
+// RequestMutatorFunc can supply an alternate outgoing request.
+type RequestMutatorFunc func(incoming *http.Request, outgoing *http.Request) *http.Request
+
+// Proxy provides websocket transport upgrade to compatible endpoints.
+type Proxy struct {
+	h                   http.Handler
+	logger              Logger
+	methodOverrideParam string
+	tokenCookieName     string
+	requestMutator      RequestMutatorFunc
+}
+
+// Logger collects log messages.
+type Logger interface {
+	Warnln(...interface{})
+	Debugln(...interface{})
+}
+
+func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if !websocket.IsWebSocketUpgrade(r) {
+		p.h.ServeHTTP(w, r)
+		return
+	}
+	p.proxy(w, r)
+}
+
+// Option allows customization of the proxy.
+type Option func(*Proxy)
+
+// WithMethodParamOverride allows specification of the special http parameter that is used in the proxied streaming request.
+func WithMethodParamOverride(param string) Option {
+	return func(p *Proxy) {
+		p.methodOverrideParam = param
+	}
+}
+
+// WithTokenCookieName allows specification of the cookie that is supplied as an upstream 'Authorization: Bearer' http header.
+func WithTokenCookieName(param string) Option {
+	return func(p *Proxy) {
+		p.tokenCookieName = param
+	}
+}
+
+// WithRequestMutator allows a custom RequestMutatorFunc to be supplied.
+func WithRequestMutator(fn RequestMutatorFunc) Option {
+	return func(p *Proxy) {
+		p.requestMutator = fn
+	}
+}
+
+// WithLogger allows a custom FieldLogger to be supplied
+func WithLogger(logger Logger) Option {
+	return func(p *Proxy) {
+		p.logger = logger
+	}
+}
+
+// WebsocketProxy attempts to expose the underlying handler as a bidi websocket stream with newline-delimited
+// JSON as the content encoding.
+//
+// The HTTP Authorization header is either populated from the Sec-Websocket-Protocol field or by a cookie.
+// The cookie name is specified by the TokenCookieName value.
+//
+// example:
+//   Sec-Websocket-Protocol: Bearer, foobar
+// is converted to:
+//   Authorization: Bearer foobar
+//
+// Method can be overwritten with the MethodOverrideParam get parameter in the requested URL
+func WebsocketProxy(h http.Handler, opts ...Option) http.Handler {
+	p := &Proxy{
+		h:                   h,
+		logger:              logrus.New(),
+		methodOverrideParam: MethodOverrideParam,
+		tokenCookieName:     TokenCookieName,
+	}
+	for _, o := range opts {
+		o(p)
+	}
+	return p
+}
+
+// TODO(tmc): allow modification of upgrader settings?
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  1024,
+	WriteBufferSize: 1024,
+	CheckOrigin:     func(r *http.Request) bool { return true },
+}
+
+func isClosedConnError(err error) bool {
+	str := err.Error()
+	if strings.Contains(str, "use of closed network connection") {
+		return true
+	}
+	return websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway)
+}
+
+func (p *Proxy) proxy(w http.ResponseWriter, r *http.Request) {
+	var responseHeader http.Header
+	// If Sec-WebSocket-Protocol starts with "Bearer", respond in kind.
+	// TODO(tmc): consider customizability/extension point here.
+	if strings.HasPrefix(r.Header.Get("Sec-WebSocket-Protocol"), "Bearer") {
+		responseHeader = http.Header{
+			"Sec-WebSocket-Protocol": []string{"Bearer"},
+		}
+	}
+	conn, err := upgrader.Upgrade(w, r, responseHeader)
+	if err != nil {
+		p.logger.Warnln("error upgrading websocket:", err)
+		return
+	}
+	defer conn.Close()
+
+	ctx, cancelFn := context.WithCancel(context.Background())
+	defer cancelFn()
+
+	requestBodyR, requestBodyW := io.Pipe()
+	request, err := http.NewRequest(r.Method, r.URL.String(), requestBodyR)
+	if err != nil {
+		p.logger.Warnln("error preparing request:", err)
+		return
+	}
+	if swsp := r.Header.Get("Sec-WebSocket-Protocol"); swsp != "" {
+		request.Header.Set("Authorization", strings.Replace(swsp, "Bearer, ", "Bearer ", 1))
+	}
+	// If token cookie is present, populate Authorization header from the cookie instead.
+	if cookie, err := r.Cookie(p.tokenCookieName); err == nil {
+		request.Header.Set("Authorization", "Bearer "+cookie.Value)
+	}
+	if m := r.URL.Query().Get(p.methodOverrideParam); m != "" {
+		request.Method = m
+	}
+
+	if p.requestMutator != nil {
+		request = p.requestMutator(r, request)
+	}
+
+	responseBodyR, responseBodyW := io.Pipe()
+	response := newInMemoryResponseWriter(responseBodyW)
+	go func() {
+		<-ctx.Done()
+		p.logger.Debugln("closing pipes")
+		requestBodyW.CloseWithError(io.EOF)
+		responseBodyW.CloseWithError(io.EOF)
+		response.closed <- true
+	}()
+
+	go func() {
+		defer cancelFn()
+		p.h.ServeHTTP(response, request)
+	}()
+
+	// read loop -- take messages from websocket and write to http request
+	go func() {
+		defer func() {
+			cancelFn()
+		}()
+		for {
+			select {
+			case <-ctx.Done():
+				p.logger.Debugln("read loop done")
+				return
+			default:
+			}
+			p.logger.Debugln("[read] reading from socket.")
+			_, payload, err := conn.ReadMessage()
+			if err != nil {
+				if isClosedConnError(err) {
+					p.logger.Debugln("[read] websocket closed:", err)
+					return
+				}
+				p.logger.Warnln("error reading websocket message:", err)
+				return
+			}
+			p.logger.Debugln("[read] read payload:", string(payload))
+			p.logger.Debugln("[read] writing to requestBody:")
+			n, err := requestBodyW.Write(payload)
+			requestBodyW.Write([]byte("\n"))
+			p.logger.Debugln("[read] wrote to requestBody", n)
+			if err != nil {
+				p.logger.Warnln("[read] error writing message to upstream http server:", err)
+				return
+			}
+		}
+	}()
+	// write loop -- take messages from response and write to websocket
+	scanner := bufio.NewScanner(responseBodyR)
+	for scanner.Scan() {
+		if len(scanner.Bytes()) == 0 {
+			p.logger.Warnln("[write] empty scan", scanner.Err())
+			continue
+		}
+		p.logger.Debugln("[write] scanned", scanner.Text())
+		if err = conn.WriteMessage(websocket.TextMessage, scanner.Bytes()); err != nil {
+			p.logger.Warnln("[write] error writing websocket message:", err)
+			return
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		p.logger.Warnln("scanner err:", err)
+	}
+}
+
+type inMemoryResponseWriter struct {
+	io.Writer
+	header http.Header
+	code   int
+	closed chan bool
+}
+
+func newInMemoryResponseWriter(w io.Writer) *inMemoryResponseWriter {
+	return &inMemoryResponseWriter{
+		Writer: w,
+		header: http.Header{},
+		closed: make(chan bool, 1),
+	}
+}
+
+func (w *inMemoryResponseWriter) Write(b []byte) (int, error) {
+	return w.Writer.Write(b)
+}
+func (w *inMemoryResponseWriter) Header() http.Header {
+	return w.header
+}
+func (w *inMemoryResponseWriter) WriteHeader(code int) {
+	w.code = code
+}
+func (w *inMemoryResponseWriter) CloseNotify() <-chan bool {
+	return w.closed
+}
+func (w *inMemoryResponseWriter) Flush() {}
diff --git a/vendor/github.com/ugorji/go/codec/0doc.go b/vendor/github.com/ugorji/go/codec/0doc.go
index 209f9ebad5b..cfb804ec147 100644
--- a/vendor/github.com/ugorji/go/codec/0doc.go
+++ b/vendor/github.com/ugorji/go/codec/0doc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 /*
-High Performance, Feature-Rich Idiomatic Go codec/encoding library for 
-binc, msgpack, cbor, json.
+High Performance, Feature-Rich Idiomatic Go 1.4+ codec/encoding library for
+binc, msgpack, cbor, json
 
 Supported Serialization formats are:
 
@@ -11,21 +11,17 @@ Supported Serialization formats are:
   - binc:    http://github.com/ugorji/binc
   - cbor:    http://cbor.io http://tools.ietf.org/html/rfc7049
   - json:    http://json.org http://tools.ietf.org/html/rfc7159
-  - simple: 
+  - simple:
 
 To install:
 
     go get github.com/ugorji/go/codec
 
-This package understands the 'unsafe' tag, to allow using unsafe semantics:
-
-  - When decoding into a struct, you need to read the field name as a string 
-    so you can find the struct field it is mapped to.
-    Using `unsafe` will bypass the allocation and copying overhead of []byte->string conversion.
-
-To install using unsafe, pass the 'unsafe' tag:
-
-    go get -tags=unsafe github.com/ugorji/go/codec
+This package will carefully use 'unsafe' for performance reasons in specific places.
+You can build without unsafe use by passing the safe or appengine tag
+i.e. 'go install -tags=safe ...'. Note that unsafe is only supported for the last 3
+go sdk versions e.g. current go release is go 1.9, so we support unsafe use only from
+go 1.7+ . This is because supporting unsafe requires knowledge of implementation details.
 
 For detailed usage information, read the primer at http://ugorji.net/blog/go-codec-primer .
 
@@ -35,12 +31,17 @@ the standard library (ie json, xml, gob, etc).
 Rich Feature Set includes:
 
   - Simple but extremely powerful and feature-rich API
+  - Support for go1.4 and above, while selectively using newer APIs for later releases
+  - Good code coverage ( > 70% )
   - Very High Performance.
     Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
+  - Careful selected use of 'unsafe' for targeted performance gains.
+    100% mode exists where 'unsafe' is not used at all.
+  - Lock-free (sans mutex) concurrency for scaling to 100's of cores
   - Multiple conversions:
-    Package coerces types where appropriate 
+    Package coerces types where appropriate
     e.g. decode an int in the stream into a float, etc.
-  - Corner Cases: 
+  - Corner Cases:
     Overflows, nil maps/slices, nil values in streams are handled correctly
   - Standard field renaming via tags
   - Support for omitting empty fields during an encoding
@@ -56,7 +57,7 @@ Rich Feature Set includes:
   - Fast (no-reflection) encoding/decoding of common maps and slices
   - Code-generation for faster performance.
   - Support binary (e.g. messagepack, cbor) and text (e.g. json) formats
-  - Support indefinite-length formats to enable true streaming 
+  - Support indefinite-length formats to enable true streaming
     (for formats which support it e.g. json, cbor)
   - Support canonical encoding, where a value is ALWAYS encoded as same sequence of bytes.
     This mostly applies to maps, where iteration order is non-deterministic.
@@ -68,12 +69,12 @@ Rich Feature Set includes:
   - Encode/Decode from/to chan types (for iterative streaming support)
   - Drop-in replacement for encoding/json. `json:` key in struct tag supported.
   - Provides a RPC Server and Client Codec for net/rpc communication protocol.
-  - Handle unique idiosyncrasies of codecs e.g. 
-    - For messagepack, configure how ambiguities in handling raw bytes are resolved 
-    - For messagepack, provide rpc server/client codec to support 
+  - Handle unique idiosyncrasies of codecs e.g.
+    - For messagepack, configure how ambiguities in handling raw bytes are resolved
+    - For messagepack, provide rpc server/client codec to support
       msgpack-rpc protocol defined at:
       https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
-  
+
 Extension Support
 
 Users can register a function to handle the encoding or decoding of
@@ -160,40 +161,25 @@ Sample usage model:
     //OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
     client := rpc.NewClientWithCodec(rpcCodec)
 
+Running Tests
+
+To run tests, use the following:
+
+    go test
+
+To run the full suite of tests, use the following:
+
+    go test -tags alltests -run Suite
+
+You can run the tag 'safe' to run tests or build in safe mode. e.g.
+
+    go test -tags safe -run Json
+    go test -tags "alltests safe" -run Suite
+
+Running Benchmarks
+
+Please see http://github.com/ugorji/go-codec-bench .
+
 */
 package codec
 
-// Benefits of go-codec:
-//
-//    - encoding/json always reads whole file into memory first.
-//      This makes it unsuitable for parsing very large files.
-//    - encoding/xml cannot parse into a map[string]interface{}
-//      I found this out on reading https://github.com/clbanning/mxj
-
-// TODO:
-//
-//   - optimization for codecgen:
-//     if len of entity is <= 3 words, then support a value receiver for encode.
-//   - (En|De)coder should store an error when it occurs.
-//     Until reset, subsequent calls return that error that was stored.
-//     This means that free panics must go away.
-//     All errors must be raised through errorf method.
-//   - Decoding using a chan is good, but incurs concurrency costs.
-//     This is because there's no fast way to use a channel without it
-//     having to switch goroutines constantly.
-//     Callback pattern is still the best. Maybe consider supporting something like:
-//        type X struct {
-//             Name string
-//             Ys []Y
-//             Ys chan <- Y
-//             Ys func(Y) -> call this function for each entry
-//        }
-//    - Consider adding a isZeroer interface { isZero() bool }
-//      It is used within isEmpty, for omitEmpty support.
-//    - Consider making Handle used AS-IS within the encoding/decoding session.
-//      This means that we don't cache Handle information within the (En|De)coder,
-//      except we really need it at Reset(...)
-//    - Consider adding math/big support
-//    - Consider reducing the size of the generated functions:
-//      Maybe use one loop, and put the conditionals in the loop.
-//      for ... { if cLen > 0 { if j == cLen { break } } else if dd.CheckBreak() { break } }
diff --git a/vendor/github.com/ugorji/go/codec/BUILD b/vendor/github.com/ugorji/go/codec/BUILD
index ead58f3b25d..ef8043cfb88 100644
--- a/vendor/github.com/ugorji/go/codec/BUILD
+++ b/vendor/github.com/ugorji/go/codec/BUILD
@@ -7,26 +7,29 @@ go_library(
         "binc.go",
         "cbor.go",
         "decode.go",
-        "decode_go.go",
-        "decode_go14.go",
         "encode.go",
         "fast-path.generated.go",
         "gen.generated.go",
-        "gen.go",
         "gen-helper.generated.go",
-        "gen_15.go",
-        "gen_16.go",
-        "gen_17.go",
+        "goversion_arrayof_gte_go15.go",
+        "goversion_arrayof_lt_go15.go",
+        "goversion_makemap_gte_go19.go",
+        "goversion_makemap_lt_go19.go",
+        "goversion_unsupported_lt_go14.go",
+        "goversion_vendor_eq_go15.go",
+        "goversion_vendor_eq_go16.go",
+        "goversion_vendor_gte_go17.go",
+        "goversion_vendor_lt_go15.go",
         "helper.go",
         "helper_internal.go",
         "helper_not_unsafe.go",
+        "helper_unsafe.go",
         "json.go",
         "msgpack.go",
-        "noop.go",
-        "prebuild.go",
         "rpc.go",
         "simple.go",
         "time.go",
+        "z.go",
     ],
     importmap = "k8s.io/kubernetes/vendor/github.com/ugorji/go/codec",
     importpath = "github.com/ugorji/go/codec",
diff --git a/vendor/github.com/ugorji/go/codec/README.md b/vendor/github.com/ugorji/go/codec/README.md
index 91cb3a27bd5..cadc41b4caa 100644
--- a/vendor/github.com/ugorji/go/codec/README.md
+++ b/vendor/github.com/ugorji/go/codec/README.md
@@ -15,17 +15,11 @@ To install:
 
     go get github.com/ugorji/go/codec
 
-This package understands the `unsafe` tag, to allow using unsafe semantics:
-
-  - When decoding into a struct, you need to read the field name as a string 
-    so you can find the struct field it is mapped to.
-    Using `unsafe` will bypass the allocation and copying overhead of `[]byte->string` conversion.
-
-To use it, you must pass the `unsafe` tag during install:
-
-```
-go install -tags=unsafe github.com/ugorji/go/codec 
-```
+This package will carefully use 'unsafe' for performance reasons in specific places.
+You can build without unsafe use by passing the safe or appengine tag
+i.e. 'go install -tags=safe ...'. Note that unsafe is only supported for the last 3
+go sdk versions e.g. current go release is go 1.9, so we support unsafe use only from
+go 1.7+ . This is because supporting unsafe requires knowledge of implementation details.
 
 Online documentation: http://godoc.org/github.com/ugorji/go/codec  
 Detailed Usage/How-to Primer: http://ugorji.net/blog/go-codec-primer
@@ -36,8 +30,13 @@ the standard library (ie json, xml, gob, etc).
 Rich Feature Set includes:
 
   - Simple but extremely powerful and feature-rich API
+  - Support for go1.4 and above, while selectively using newer APIs for later releases
+  - Good code coverage ( > 70% )
   - Very High Performance.
     Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
+  - Careful selected use of 'unsafe' for targeted performance gains.
+    100% mode exists where 'unsafe' is not used at all.
+  - Lock-free (sans mutex) concurrency for scaling to 100's of cores
   - Multiple conversions:
     Package coerces types where appropriate 
     e.g. decode an int in the stream into a float, etc.
@@ -146,3 +145,22 @@ Typical usage model:
     //OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
     client := rpc.NewClientWithCodec(rpcCodec)
 
+## Running Tests
+
+To run tests, use the following:
+
+    go test
+
+To run the full suite of tests, use the following:
+
+    go test -tags alltests -run Suite
+
+You can run the tag 'safe' to run tests or build in safe mode. e.g.
+
+    go test -tags safe -run Json
+    go test -tags "alltests safe" -run Suite
+
+## Running Benchmarks
+
+Please see http://github.com/ugorji/go-codec-bench .
+
diff --git a/vendor/github.com/ugorji/go/codec/binc.go b/vendor/github.com/ugorji/go/codec/binc.go
index 33120dcb61f..be5b7d33804 100644
--- a/vendor/github.com/ugorji/go/codec/binc.go
+++ b/vendor/github.com/ugorji/go/codec/binc.go
@@ -61,7 +61,8 @@ type bincEncDriver struct {
 	m map[string]uint16 // symbols
 	b [scratchByteArrayLen]byte
 	s uint16 // symbols sequencer
-	encNoSeparator
+	// encNoSeparator
+	encDriverNoopContainerWriter
 }
 
 func (e *bincEncDriver) IsBuiltinType(rt uintptr) bool {
@@ -195,11 +196,11 @@ func (e *bincEncDriver) encodeExtPreamble(xtag byte, length int) {
 	e.w.writen1(xtag)
 }
 
-func (e *bincEncDriver) EncodeArrayStart(length int) {
+func (e *bincEncDriver) WriteArrayStart(length int) {
 	e.encLen(bincVdArray<<4, uint64(length))
 }
 
-func (e *bincEncDriver) EncodeMapStart(length int) {
+func (e *bincEncDriver) WriteMapStart(length int) {
 	e.encLen(bincVdMap<<4, uint64(length))
 }
 
@@ -332,13 +333,14 @@ type bincDecDriver struct {
 	bd     byte
 	vd     byte
 	vs     byte
-	noStreamingCodec
-	decNoSeparator
+	// noStreamingCodec
+	// decNoSeparator
 	b [scratchByteArrayLen]byte
 
 	// linear searching on this slice is ok,
 	// because we typically expect < 32 symbols in each stream.
 	s []bincDecSymbol
+	decDriverNoopContainerReader
 }
 
 func (d *bincDecDriver) readNextBd() {
@@ -356,6 +358,9 @@ func (d *bincDecDriver) uncacheRead() {
 }
 
 func (d *bincDecDriver) ContainerType() (vt valueType) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	if d.vd == bincVdSpecial && d.vs == bincSpNil {
 		return valueTypeNil
 	} else if d.vd == bincVdByteArray {
@@ -509,7 +514,7 @@ func (d *bincDecDriver) DecodeInt(bitsize uint8) (i int64) {
 		i = -i
 	}
 	if chkOvf.Int(i, bitsize) {
-		d.d.errorf("binc: overflow integer: %v", i)
+		d.d.errorf("binc: overflow integer: %v for num bits: %v", i, bitsize)
 		return
 	}
 	d.bdRead = false
@@ -580,6 +585,9 @@ func (d *bincDecDriver) DecodeBool() (b bool) {
 }
 
 func (d *bincDecDriver) ReadMapStart() (length int) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	if d.vd != bincVdMap {
 		d.d.errorf("Invalid d.vd for map. Expecting 0x%x. Got: 0x%x", bincVdMap, d.vd)
 		return
@@ -590,6 +598,9 @@ func (d *bincDecDriver) ReadMapStart() (length int) {
 }
 
 func (d *bincDecDriver) ReadArrayStart() (length int) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	if d.vd != bincVdArray {
 		d.d.errorf("Invalid d.vd for array. Expecting 0x%x. Got: 0x%x", bincVdArray, d.vd)
 		return
@@ -639,12 +650,12 @@ func (d *bincDecDriver) decStringAndBytes(bs []byte, withString, zerocopy bool)
 			if d.br {
 				bs2 = d.r.readx(slen)
 			} else if len(bs) == 0 {
-				bs2 = decByteSlice(d.r, slen, d.b[:])
+				bs2 = decByteSlice(d.r, slen, d.d.h.MaxInitLen, d.b[:])
 			} else {
-				bs2 = decByteSlice(d.r, slen, bs)
+				bs2 = decByteSlice(d.r, slen, d.d.h.MaxInitLen, bs)
 			}
 		} else {
-			bs2 = decByteSlice(d.r, slen, bs)
+			bs2 = decByteSlice(d.r, slen, d.d.h.MaxInitLen, bs)
 		}
 		if withString {
 			s = string(bs2)
@@ -696,7 +707,7 @@ func (d *bincDecDriver) decStringAndBytes(bs []byte, withString, zerocopy bool)
 			// since using symbols, do not store any part of
 			// the parameter bs in the map, as it might be a shared buffer.
 			// bs2 = decByteSlice(d.r, slen, bs)
-			bs2 = decByteSlice(d.r, slen, nil)
+			bs2 = decByteSlice(d.r, slen, d.d.h.MaxInitLen, nil)
 			if withString {
 				s = string(bs2)
 			}
@@ -719,11 +730,12 @@ func (d *bincDecDriver) DecodeString() (s string) {
 	return
 }
 
-func (d *bincDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) {
-	if isstring {
-		bsOut, _ = d.decStringAndBytes(bs, false, zerocopy)
-		return
-	}
+func (d *bincDecDriver) DecodeStringAsBytes() (s []byte) {
+	s, _ = d.decStringAndBytes(d.b[:], false, true)
+	return
+}
+
+func (d *bincDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -747,7 +759,7 @@ func (d *bincDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut [
 			bs = d.b[:]
 		}
 	}
-	return decByteSlice(d.r, clen, bs)
+	return decByteSlice(d.r, clen, d.d.h.MaxInitLen, bs)
 }
 
 func (d *bincDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) {
@@ -780,7 +792,7 @@ func (d *bincDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs []b
 		}
 		xbs = d.r.readx(l)
 	} else if d.vd == bincVdByteArray {
-		xbs = d.DecodeBytes(nil, false, true)
+		xbs = d.DecodeBytes(nil, true)
 	} else {
 		d.d.errorf("Invalid d.vd for extensions (Expecting extensions or byte array). Got: 0x%x", d.vd)
 		return
@@ -794,7 +806,7 @@ func (d *bincDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch d.vd {
@@ -849,7 +861,7 @@ func (d *bincDecDriver) DecodeNaked() {
 		n.s = d.DecodeString()
 	case bincVdByteArray:
 		n.v = valueTypeBytes
-		n.l = d.DecodeBytes(nil, false, false)
+		n.l = d.DecodeBytes(nil, false)
 	case bincVdTimestamp:
 		n.v = valueTypeTimestamp
 		tt, err := decodeTime(d.r.readx(int(d.vs)))
@@ -899,6 +911,7 @@ func (d *bincDecDriver) DecodeNaked() {
 type BincHandle struct {
 	BasicHandle
 	binaryEncodingType
+	noElemSeparators
 }
 
 func (h *BincHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
@@ -910,7 +923,11 @@ func (h *BincHandle) newEncDriver(e *Encoder) encDriver {
 }
 
 func (h *BincHandle) newDecDriver(d *Decoder) decDriver {
-	return &bincDecDriver{d: d, r: d.r, h: h, br: d.bytes}
+	return &bincDecDriver{d: d, h: h, r: d.r, br: d.bytes}
+}
+
+func (_ *BincHandle) IsBuiltinType(rt uintptr) bool {
+	return rt == timeTypId
 }
 
 func (e *bincEncDriver) reset() {
@@ -920,7 +937,7 @@ func (e *bincEncDriver) reset() {
 }
 
 func (d *bincDecDriver) reset() {
-	d.r = d.d.r
+	d.r, d.br = d.d.r, d.d.bytes
 	d.s = nil
 	d.bd, d.bdRead, d.vd, d.vs = 0, false, 0, 0
 }
diff --git a/vendor/github.com/ugorji/go/codec/cbor.go b/vendor/github.com/ugorji/go/codec/cbor.go
index 4fa349ac87f..592cee851ba 100644
--- a/vendor/github.com/ugorji/go/codec/cbor.go
+++ b/vendor/github.com/ugorji/go/codec/cbor.go
@@ -61,7 +61,8 @@ const (
 
 type cborEncDriver struct {
 	noBuiltInTypes
-	encNoSeparator
+	encDriverNoopContainerWriter
+	// encNoSeparator
 	e *Encoder
 	w encWriter
 	h *CborHandle
@@ -134,21 +135,41 @@ func (e *cborEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Enco
 
 func (e *cborEncDriver) EncodeRawExt(re *RawExt, en *Encoder) {
 	e.encUint(uint64(re.Tag), cborBaseTag)
-	if re.Data != nil {
+	if false && re.Data != nil {
 		en.encode(re.Data)
-	} else if re.Value == nil {
-		e.EncodeNil()
-	} else {
+	} else if re.Value != nil {
 		en.encode(re.Value)
+	} else {
+		e.EncodeNil()
 	}
 }
 
-func (e *cborEncDriver) EncodeArrayStart(length int) {
-	e.encLen(cborBaseArray, length)
+func (e *cborEncDriver) WriteArrayStart(length int) {
+	if e.h.IndefiniteLength {
+		e.w.writen1(cborBdIndefiniteArray)
+	} else {
+		e.encLen(cborBaseArray, length)
+	}
 }
 
-func (e *cborEncDriver) EncodeMapStart(length int) {
-	e.encLen(cborBaseMap, length)
+func (e *cborEncDriver) WriteMapStart(length int) {
+	if e.h.IndefiniteLength {
+		e.w.writen1(cborBdIndefiniteMap)
+	} else {
+		e.encLen(cborBaseMap, length)
+	}
+}
+
+func (e *cborEncDriver) WriteMapEnd() {
+	if e.h.IndefiniteLength {
+		e.w.writen1(cborBdBreak)
+	}
+}
+
+func (e *cborEncDriver) WriteArrayEnd() {
+	if e.h.IndefiniteLength {
+		e.w.writen1(cborBdBreak)
+	}
 }
 
 func (e *cborEncDriver) EncodeString(c charEncoding, v string) {
@@ -180,7 +201,8 @@ type cborDecDriver struct {
 	bdRead bool
 	bd     byte
 	noBuiltInTypes
-	decNoSeparator
+	// decNoSeparator
+	decDriverNoopContainerReader
 }
 
 func (d *cborDecDriver) readNextBd() {
@@ -196,6 +218,9 @@ func (d *cborDecDriver) uncacheRead() {
 }
 
 func (d *cborDecDriver) ContainerType() (vt valueType) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	if d.bd == cborBdNil {
 		return valueTypeNil
 	} else if d.bd == cborBdIndefiniteBytes || (d.bd >= cborBaseBytes && d.bd < cborBaseString) {
@@ -351,6 +376,9 @@ func (d *cborDecDriver) DecodeBool() (b bool) {
 }
 
 func (d *cborDecDriver) ReadMapStart() (length int) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	d.bdRead = false
 	if d.bd == cborBdIndefiniteMap {
 		return -1
@@ -359,6 +387,9 @@ func (d *cborDecDriver) ReadMapStart() (length int) {
 }
 
 func (d *cborDecDriver) ReadArrayStart() (length int) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	d.bdRead = false
 	if d.bd == cborBdIndefiniteArray {
 		return -1
@@ -398,7 +429,7 @@ func (d *cborDecDriver) decAppendIndefiniteBytes(bs []byte) []byte {
 	return bs
 }
 
-func (d *cborDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) {
+func (d *cborDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -421,11 +452,15 @@ func (d *cborDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut [
 			bs = d.b[:]
 		}
 	}
-	return decByteSlice(d.r, clen, bs)
+	return decByteSlice(d.r, clen, d.d.h.MaxInitLen, bs)
 }
 
 func (d *cborDecDriver) DecodeString() (s string) {
-	return string(d.DecodeBytes(d.b[:], true, true))
+	return string(d.DecodeBytes(d.b[:], true))
+}
+
+func (d *cborDecDriver) DecodeStringAsBytes() (s []byte) {
+	return d.DecodeBytes(d.b[:], true)
 }
 
 func (d *cborDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) {
@@ -456,7 +491,7 @@ func (d *cborDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch d.bd {
@@ -476,7 +511,7 @@ func (d *cborDecDriver) DecodeNaked() {
 		n.f = d.DecodeFloat(false)
 	case cborBdIndefiniteBytes:
 		n.v = valueTypeBytes
-		n.l = d.DecodeBytes(nil, false, false)
+		n.l = d.DecodeBytes(nil, false)
 	case cborBdIndefiniteString:
 		n.v = valueTypeString
 		n.s = d.DecodeString()
@@ -501,7 +536,7 @@ func (d *cborDecDriver) DecodeNaked() {
 			n.i = d.DecodeInt(64)
 		case d.bd >= cborBaseBytes && d.bd < cborBaseString:
 			n.v = valueTypeBytes
-			n.l = d.DecodeBytes(nil, false, false)
+			n.l = d.DecodeBytes(nil, false)
 		case d.bd >= cborBaseString && d.bd < cborBaseArray:
 			n.v = valueTypeString
 			n.s = d.DecodeString()
@@ -564,7 +599,11 @@ func (d *cborDecDriver) DecodeNaked() {
 //
 type CborHandle struct {
 	binaryEncodingType
+	noElemSeparators
 	BasicHandle
+
+	// IndefiniteLength=true, means that we encode using indefinitelength
+	IndefiniteLength bool
 }
 
 func (h *CborHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
@@ -576,7 +615,7 @@ func (h *CborHandle) newEncDriver(e *Encoder) encDriver {
 }
 
 func (h *CborHandle) newDecDriver(d *Decoder) decDriver {
-	return &cborDecDriver{d: d, r: d.r, h: h, br: d.bytes}
+	return &cborDecDriver{d: d, h: h, r: d.r, br: d.bytes}
 }
 
 func (e *cborEncDriver) reset() {
@@ -584,7 +623,7 @@ func (e *cborEncDriver) reset() {
 }
 
 func (d *cborDecDriver) reset() {
-	d.r = d.d.r
+	d.r, d.br = d.d.r, d.d.bytes
 	d.bd, d.bdRead = 0, false
 }
 
diff --git a/vendor/github.com/ugorji/go/codec/decode.go b/vendor/github.com/ugorji/go/codec/decode.go
index 52c1dfe836b..246533f3298 100644
--- a/vendor/github.com/ugorji/go/codec/decode.go
+++ b/vendor/github.com/ugorji/go/codec/decode.go
@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"io"
 	"reflect"
+	"sync"
 	"time"
 )
 
@@ -21,6 +22,10 @@ const (
 var (
 	onlyMapOrArrayCanDecodeIntoStructErr = errors.New("only encoded map or array can be decoded into a struct")
 	cannotDecodeIntoNilErr               = errors.New("cannot decode into nil")
+
+	decUnreadByteNothingToReadErr   = errors.New("cannot unread - nothing has been read")
+	decUnreadByteLastByteNotReadErr = errors.New("cannot unread - last byte has not been read")
+	decUnreadByteUnknownErr         = errors.New("cannot unread - reason unknown")
 )
 
 // decReader abstracts the reading source, allowing implementations that can
@@ -34,24 +39,37 @@ type decReader interface {
 	readx(n int) []byte
 	readb([]byte)
 	readn1() uint8
-	readn1eof() (v uint8, eof bool)
+	readn3() (uint8, uint8, uint8)
+	readn4() (uint8, uint8, uint8, uint8)
+	// readn1eof() (v uint8, eof bool)
 	numread() int // number of bytes read
 	track()
 	stopTrack() []byte
+
+	// skip will skip any byte that matches, and return the first non-matching byte
+	skip(accept *bitset256) (token byte)
+	// readTo will read any byte that matches, stopping once no-longer matching.
+	readTo(in []byte, accept *bitset256) (out []byte)
+	// readUntil will read, only stopping once it matches the 'stop' byte.
+	readUntil(in []byte, stop byte) (out []byte)
 }
 
-type decReaderByteScanner interface {
-	io.Reader
-	io.ByteScanner
-}
+// type decReaderByteScanner interface {
+// 	io.Reader
+// 	io.ByteScanner
+// }
 
 type decDriver interface {
 	// this will check if the next token is a break.
 	CheckBreak() bool
+	// Note: TryDecodeAsNil should be careful not to share any temporary []byte with
+	// the rest of the decDriver. This is because sometimes, we optimize by holding onto
+	// a transient []byte, and ensuring the only other call we make to the decDriver
+	// during that time is maybe a TryDecodeAsNil() call.
 	TryDecodeAsNil() bool
 	// vt is one of: Bytes, String, Nil, Slice or Map. Return unSet if not known.
 	ContainerType() (vt valueType)
-	IsBuiltinType(rt uintptr) bool
+	// IsBuiltinType(rt uintptr) bool
 	DecodeBuiltin(rt uintptr, v interface{})
 
 	// DecodeNaked will decode primitives (number, bool, string, []byte) and RawExt.
@@ -76,25 +94,41 @@ type decDriver interface {
 	// return a pre-stored string value, meaning that it can bypass
 	// the cost of []byte->string conversion.
 	DecodeString() (s string)
+	DecodeStringAsBytes() (v []byte)
 
 	// DecodeBytes may be called directly, without going through reflection.
 	// Consequently, it must be designed to handle possible nil.
-	DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte)
+	DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte)
+	// DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte)
 
 	// decodeExt will decode into a *RawExt or into an extension.
 	DecodeExt(v interface{}, xtag uint64, ext Ext) (realxtag uint64)
 	// decodeExt(verifyTag bool, tag byte) (xtag byte, xbs []byte)
-	ReadMapStart() int
 	ReadArrayStart() int
+	ReadArrayElem()
+	ReadArrayEnd()
+	ReadMapStart() int
+	ReadMapElemKey()
+	ReadMapElemValue()
+	ReadMapEnd()
 
 	reset()
 	uncacheRead()
 }
 
-type decNoSeparator struct {
-}
+// type decNoSeparator struct {}
+// func (_ decNoSeparator) ReadEnd() {}
 
-func (_ decNoSeparator) ReadEnd() {}
+type decDriverNoopContainerReader struct{}
+
+func (_ decDriverNoopContainerReader) ReadArrayStart() (v int) { return }
+func (_ decDriverNoopContainerReader) ReadArrayElem()          {}
+func (_ decDriverNoopContainerReader) ReadArrayEnd()           {}
+func (_ decDriverNoopContainerReader) ReadMapStart() (v int)   { return }
+func (_ decDriverNoopContainerReader) ReadMapElemKey()         {}
+func (_ decDriverNoopContainerReader) ReadMapElemValue()       {}
+func (_ decDriverNoopContainerReader) ReadMapEnd()             {}
+func (_ decDriverNoopContainerReader) CheckBreak() (v bool)    { return }
 
 // func (_ decNoSeparator) uncacheRead() {}
 
@@ -107,10 +141,10 @@ type DecodeOptions struct {
 	// If nil, we use []interface{}
 	SliceType reflect.Type
 
-	// MaxInitLen defines the initial length that we "make" a collection (slice, chan or map) with.
+	// MaxInitLen defines the maxinum initial length that we "make" a collection (string, slice, map, chan).
 	// If 0 or negative, we default to a sensible value based on the size of an element in the collection.
 	//
-	// For example, when decoding, a stream may say that it has MAX_UINT elements.
+	// For example, when decoding, a stream may say that it has 2^64 elements.
 	// We should not auto-matically provision a slice of that length, to prevent Out-Of-Memory crash.
 	// Instead, we provision up to MaxInitLen, fill that up, and start appending after that.
 	MaxInitLen int
@@ -141,6 +175,11 @@ type DecodeOptions struct {
 	// or is an interface.
 	MapValueReset bool
 
+	// SliceElementReset: on decoding a slice, reset the element to a zero value first.
+	//
+	// concern: if the slice already contained some garbage, we will decode into that garbage.
+	SliceElementReset bool
+
 	// InterfaceReset controls how we decode into an interface.
 	//
 	// By default, when we see a field that is an interface{...},
@@ -161,7 +200,9 @@ type DecodeOptions struct {
 	// look them up from a map (than to allocate them afresh).
 	//
 	// Note: Handles will be smart when using the intern functionality.
-	// So everything will not be interned.
+	// Every string should not be interned.
+	// An excellent use-case for interning is struct field names,
+	// or map keys where key type is string.
 	InternString bool
 
 	// PreferArrayOverSlice controls whether to decode to an array or a slice.
@@ -172,20 +213,372 @@ type DecodeOptions struct {
 	// *Note*: This only applies if using go1.5 and above,
 	// as it requires reflect.ArrayOf support which was absent before go1.5.
 	PreferArrayOverSlice bool
+
+	// DeleteOnNilMapValue controls how to decode a nil value in the stream.
+	//
+	// If true, we will delete the mapping of the key.
+	// Else, just set the mapping to the zero value of the type.
+	DeleteOnNilMapValue bool
+
+	// ReaderBufferSize is the size of the buffer used when reading.
+	//
+	// if > 0, we use a smart buffer internally for performance purposes.
+	ReaderBufferSize int
 }
 
 // ------------------------------------
 
-// ioDecByteScanner implements Read(), ReadByte(...), UnreadByte(...) methods
-// of io.Reader, io.ByteScanner.
-type ioDecByteScanner struct {
-	r  io.Reader
-	l  byte    // last byte
-	ls byte    // last byte status. 0: init-canDoNothing, 1: canRead, 2: canUnread
-	b  [1]byte // tiny buffer for reading single bytes
+type bufioDecReader struct {
+	buf []byte
+	r   io.Reader
+
+	c   int // cursor
+	n   int // num read
+	err error
+
+	trb bool
+	tr  []byte
+
+	b [8]byte
 }
 
-func (z *ioDecByteScanner) Read(p []byte) (n int, err error) {
+func (z *bufioDecReader) reset(r io.Reader) {
+	z.r, z.c, z.n, z.err, z.trb = r, 0, 0, nil, false
+	if z.tr != nil {
+		z.tr = z.tr[:0]
+	}
+}
+
+func (z *bufioDecReader) Read(p []byte) (n int, err error) {
+	if z.err != nil {
+		return 0, z.err
+	}
+	p0 := p
+	n = copy(p, z.buf[z.c:])
+	z.c += n
+	if z.c == len(z.buf) {
+		z.c = 0
+	}
+	z.n += n
+	if len(p) == n {
+		if z.c == 0 {
+			z.buf = z.buf[:1]
+			z.buf[0] = p[len(p)-1]
+			z.c = 1
+		}
+		if z.trb {
+			z.tr = append(z.tr, p0[:n]...)
+		}
+		return
+	}
+	p = p[n:]
+	var n2 int
+	// if we are here, then z.buf is all read
+	if len(p) > len(z.buf) {
+		n2, err = decReadFull(z.r, p)
+		n += n2
+		z.n += n2
+		z.err = err
+		// don't return EOF if some bytes were read. keep for next time.
+		if n > 0 && err == io.EOF {
+			err = nil
+		}
+		// always keep last byte in z.buf
+		z.buf = z.buf[:1]
+		z.buf[0] = p[len(p)-1]
+		z.c = 1
+		if z.trb {
+			z.tr = append(z.tr, p0[:n]...)
+		}
+		return
+	}
+	// z.c is now 0, and len(p) <= len(z.buf)
+	for len(p) > 0 && z.err == nil {
+		// println("len(p) loop starting ... ")
+		z.c = 0
+		z.buf = z.buf[0:cap(z.buf)]
+		n2, err = z.r.Read(z.buf)
+		if n2 > 0 {
+			if err == io.EOF {
+				err = nil
+			}
+			z.buf = z.buf[:n2]
+			n2 = copy(p, z.buf)
+			z.c = n2
+			n += n2
+			z.n += n2
+			p = p[n2:]
+		}
+		z.err = err
+		// println("... len(p) loop done")
+	}
+	if z.c == 0 {
+		z.buf = z.buf[:1]
+		z.buf[0] = p[len(p)-1]
+		z.c = 1
+	}
+	if z.trb {
+		z.tr = append(z.tr, p0[:n]...)
+	}
+	return
+}
+
+func (z *bufioDecReader) ReadByte() (b byte, err error) {
+	z.b[0] = 0
+	_, err = z.Read(z.b[:1])
+	b = z.b[0]
+	return
+}
+
+func (z *bufioDecReader) UnreadByte() (err error) {
+	if z.err != nil {
+		return z.err
+	}
+	if z.c > 0 {
+		z.c--
+		z.n--
+		if z.trb {
+			z.tr = z.tr[:len(z.tr)-1]
+		}
+		return
+	}
+	return decUnreadByteNothingToReadErr
+}
+
+func (z *bufioDecReader) numread() int {
+	return z.n
+}
+
+func (z *bufioDecReader) readx(n int) (bs []byte) {
+	if n <= 0 || z.err != nil {
+		return
+	}
+	if z.c+n <= len(z.buf) {
+		bs = z.buf[z.c : z.c+n]
+		z.n += n
+		z.c += n
+		if z.trb {
+			z.tr = append(z.tr, bs...)
+		}
+		return
+	}
+	bs = make([]byte, n)
+	_, err := z.Read(bs)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+func (z *bufioDecReader) readb(bs []byte) {
+	_, err := z.Read(bs)
+	if err != nil {
+		panic(err)
+	}
+}
+
+// func (z *bufioDecReader) readn1eof() (b uint8, eof bool) {
+// 	b, err := z.ReadByte()
+// 	if err != nil {
+// 		if err == io.EOF {
+// 			eof = true
+// 		} else {
+// 			panic(err)
+// 		}
+// 	}
+// 	return
+// }
+
+func (z *bufioDecReader) readn1() (b uint8) {
+	b, err := z.ReadByte()
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+func (z *bufioDecReader) readn3() (b1, b2, b3 uint8) {
+	z.readb(z.b[:3])
+	return z.b[0], z.b[1], z.b[2]
+}
+
+func (z *bufioDecReader) readn4() (b1, b2, b3, b4 uint8) {
+	z.readb(z.b[:4])
+	return z.b[0], z.b[1], z.b[2], z.b[3]
+}
+
+func (z *bufioDecReader) search(in []byte, accept *bitset256, stop, flag uint8) (token byte, out []byte) {
+	// flag: 1 (skip), 2 (readTo), 4 (readUntil)
+	if flag == 4 {
+		for i := z.c; i < len(z.buf); i++ {
+			if z.buf[i] == stop {
+				token = z.buf[i]
+				z.n = z.n + (i - z.c) - 1
+				i++
+				out = z.buf[z.c:i]
+				if z.trb {
+					z.tr = append(z.tr, z.buf[z.c:i]...)
+				}
+				z.c = i
+				return
+			}
+		}
+	} else {
+		for i := z.c; i < len(z.buf); i++ {
+			if !accept.isset(z.buf[i]) {
+				token = z.buf[i]
+				z.n = z.n + (i - z.c) - 1
+				if flag == 1 {
+					i++
+				} else {
+					out = z.buf[z.c:i]
+				}
+				if z.trb {
+					z.tr = append(z.tr, z.buf[z.c:i]...)
+				}
+				z.c = i
+				return
+			}
+		}
+	}
+	z.n += len(z.buf) - z.c
+	if flag != 1 {
+		out = append(in, z.buf[z.c:]...)
+	}
+	if z.trb {
+		z.tr = append(z.tr, z.buf[z.c:]...)
+	}
+	var n2 int
+	if z.err != nil {
+		return
+	}
+	for {
+		z.c = 0
+		z.buf = z.buf[0:cap(z.buf)]
+		n2, z.err = z.r.Read(z.buf)
+		if n2 > 0 && z.err != nil {
+			z.err = nil
+		}
+		z.buf = z.buf[:n2]
+		if flag == 4 {
+			for i := 0; i < n2; i++ {
+				if z.buf[i] == stop {
+					token = z.buf[i]
+					z.n += i - 1
+					i++
+					out = append(out, z.buf[z.c:i]...)
+					if z.trb {
+						z.tr = append(z.tr, z.buf[z.c:i]...)
+					}
+					z.c = i
+					return
+				}
+			}
+		} else {
+			for i := 0; i < n2; i++ {
+				if !accept.isset(z.buf[i]) {
+					token = z.buf[i]
+					z.n += i - 1
+					if flag == 1 {
+						i++
+					}
+					if flag != 1 {
+						out = append(out, z.buf[z.c:i]...)
+					}
+					if z.trb {
+						z.tr = append(z.tr, z.buf[z.c:i]...)
+					}
+					z.c = i
+					return
+				}
+			}
+		}
+		if flag != 1 {
+			out = append(out, z.buf[:n2]...)
+		}
+		z.n += n2
+		if z.err != nil {
+			return
+		}
+		if z.trb {
+			z.tr = append(z.tr, z.buf[:n2]...)
+		}
+	}
+}
+
+func (z *bufioDecReader) skip(accept *bitset256) (token byte) {
+	token, _ = z.search(nil, accept, 0, 1)
+	return
+}
+
+func (z *bufioDecReader) readTo(in []byte, accept *bitset256) (out []byte) {
+	_, out = z.search(in, accept, 0, 2)
+	return
+}
+
+func (z *bufioDecReader) readUntil(in []byte, stop byte) (out []byte) {
+	_, out = z.search(in, nil, stop, 4)
+	return
+}
+
+func (z *bufioDecReader) unreadn1() {
+	err := z.UnreadByte()
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (z *bufioDecReader) track() {
+	if z.tr != nil {
+		z.tr = z.tr[:0]
+	}
+	z.trb = true
+}
+
+func (z *bufioDecReader) stopTrack() (bs []byte) {
+	z.trb = false
+	return z.tr
+}
+
+// ioDecReader is a decReader that reads off an io.Reader.
+//
+// It also has a fallback implementation of ByteScanner if needed.
+type ioDecReader struct {
+	r io.Reader // the reader passed in
+
+	rr io.Reader
+	br io.ByteScanner
+
+	l   byte    // last byte
+	ls  byte    // last byte status. 0: init-canDoNothing, 1: canRead, 2: canUnread
+	b   [4]byte // tiny buffer for reading single bytes
+	trb bool    // tracking bytes turned on
+
+	// temp byte array re-used internally for efficiency during read.
+	// shares buffer with Decoder, so we keep size of struct within 8 words.
+	x  *[scratchByteArrayLen]byte
+	n  int    // num read
+	tr []byte // tracking bytes read
+}
+
+func (z *ioDecReader) reset(r io.Reader) {
+	z.r = r
+	z.rr = r
+	z.l, z.ls, z.n, z.trb = 0, 0, 0, false
+	if z.tr != nil {
+		z.tr = z.tr[:0]
+	}
+	var ok bool
+	if z.br, ok = r.(io.ByteScanner); !ok {
+		z.br = z
+		z.rr = z
+	}
+}
+
+func (z *ioDecReader) Read(p []byte) (n int, err error) {
+	if len(p) == 0 {
+		return
+	}
 	var firstByte bool
 	if z.ls == 1 {
 		z.ls = 2
@@ -211,8 +604,8 @@ func (z *ioDecByteScanner) Read(p []byte) (n int, err error) {
 	return
 }
 
-func (z *ioDecByteScanner) ReadByte() (c byte, err error) {
-	n, err := z.Read(z.b[:])
+func (z *ioDecReader) ReadByte() (c byte, err error) {
+	n, err := z.Read(z.b[:1])
 	if n == 1 {
 		c = z.b[0]
 		if err == io.EOF {
@@ -222,30 +615,20 @@ func (z *ioDecByteScanner) ReadByte() (c byte, err error) {
 	return
 }
 
-func (z *ioDecByteScanner) UnreadByte() (err error) {
-	x := z.ls
-	if x == 0 {
-		err = errors.New("cannot unread - nothing has been read")
-	} else if x == 1 {
-		err = errors.New("cannot unread - last byte has not been read")
-	} else if x == 2 {
+func (z *ioDecReader) UnreadByte() (err error) {
+	switch z.ls {
+	case 2:
 		z.ls = 1
+	case 0:
+		err = decUnreadByteNothingToReadErr
+	case 1:
+		err = decUnreadByteLastByteNotReadErr
+	default:
+		err = decUnreadByteUnknownErr
 	}
 	return
 }
 
-// ioDecReader is a decReader that reads off an io.Reader
-type ioDecReader struct {
-	br decReaderByteScanner
-	// temp byte array re-used internally for efficiency during read.
-	// shares buffer with Decoder, so we keep size of struct within 8 words.
-	x   *[scratchByteArrayLen]byte
-	bs  ioDecByteScanner
-	n   int    // num read
-	tr  []byte // tracking bytes read
-	trb bool
-}
-
 func (z *ioDecReader) numread() int {
 	return z.n
 }
@@ -259,7 +642,7 @@ func (z *ioDecReader) readx(n int) (bs []byte) {
 	} else {
 		bs = make([]byte, n)
 	}
-	if _, err := io.ReadAtLeast(z.br, bs, n); err != nil {
+	if _, err := decReadFull(z.rr, bs); err != nil {
 		panic(err)
 	}
 	z.n += len(bs)
@@ -270,31 +653,18 @@ func (z *ioDecReader) readx(n int) (bs []byte) {
 }
 
 func (z *ioDecReader) readb(bs []byte) {
-	if len(bs) == 0 {
-		return
-	}
-	n, err := io.ReadAtLeast(z.br, bs, len(bs))
-	z.n += n
-	if err != nil {
+	// if len(bs) == 0 {
+	// 	return
+	// }
+	if _, err := decReadFull(z.rr, bs); err != nil {
 		panic(err)
 	}
+	z.n += len(bs)
 	if z.trb {
 		z.tr = append(z.tr, bs...)
 	}
 }
 
-func (z *ioDecReader) readn1() (b uint8) {
-	b, err := z.br.ReadByte()
-	if err != nil {
-		panic(err)
-	}
-	z.n++
-	if z.trb {
-		z.tr = append(z.tr, b)
-	}
-	return b
-}
-
 func (z *ioDecReader) readn1eof() (b uint8, eof bool) {
 	b, err := z.br.ReadByte()
 	if err == nil {
@@ -310,6 +680,72 @@ func (z *ioDecReader) readn1eof() (b uint8, eof bool) {
 	return
 }
 
+func (z *ioDecReader) readn1() (b uint8) {
+	var err error
+	if b, err = z.br.ReadByte(); err == nil {
+		z.n++
+		if z.trb {
+			z.tr = append(z.tr, b)
+		}
+		return
+	}
+	panic(err)
+}
+
+func (z *ioDecReader) readn3() (b1, b2, b3 uint8) {
+	z.readb(z.b[:3])
+	return z.b[0], z.b[1], z.b[2]
+}
+
+func (z *ioDecReader) readn4() (b1, b2, b3, b4 uint8) {
+	z.readb(z.b[:4])
+	return z.b[0], z.b[1], z.b[2], z.b[3]
+}
+
+func (z *ioDecReader) skip(accept *bitset256) (token byte) {
+	for {
+		var eof bool
+		token, eof = z.readn1eof()
+		if eof {
+			return
+		}
+		if accept.isset(token) {
+			continue
+		}
+		return
+	}
+}
+
+func (z *ioDecReader) readTo(in []byte, accept *bitset256) (out []byte) {
+	out = in
+	for {
+		token, eof := z.readn1eof()
+		if eof {
+			return
+		}
+		if accept.isset(token) {
+			out = append(out, token)
+		} else {
+			z.unreadn1()
+			return
+		}
+	}
+}
+
+func (z *ioDecReader) readUntil(in []byte, stop byte) (out []byte) {
+	out = in
+	for {
+		token, eof := z.readn1eof()
+		if eof {
+			panic(io.EOF)
+		}
+		out = append(out, token)
+		if token == stop {
+			return
+		}
+	}
+}
+
 func (z *ioDecReader) unreadn1() {
 	err := z.br.UnreadByte()
 	if err != nil {
@@ -386,6 +822,10 @@ func (z *bytesDecReader) readx(n int) (bs []byte) {
 	return
 }
 
+func (z *bytesDecReader) readb(bs []byte) {
+	copy(bs, z.readx(len(bs)))
+}
+
 func (z *bytesDecReader) readn1() (v uint8) {
 	if z.a == 0 {
 		panic(io.EOF)
@@ -396,19 +836,94 @@ func (z *bytesDecReader) readn1() (v uint8) {
 	return
 }
 
-func (z *bytesDecReader) readn1eof() (v uint8, eof bool) {
-	if z.a == 0 {
-		eof = true
-		return
+func (z *bytesDecReader) readn3() (b1, b2, b3 uint8) {
+	if 3 > z.a {
+		panic(io.ErrUnexpectedEOF)
 	}
-	v = z.b[z.c]
-	z.c++
-	z.a--
+	b3 = z.b[z.c+2]
+	b2 = z.b[z.c+1]
+	b1 = z.b[z.c]
+	z.c += 3
+	z.a -= 3
 	return
 }
 
-func (z *bytesDecReader) readb(bs []byte) {
-	copy(bs, z.readx(len(bs)))
+func (z *bytesDecReader) readn4() (b1, b2, b3, b4 uint8) {
+	if 4 > z.a {
+		panic(io.ErrUnexpectedEOF)
+	}
+	b4 = z.b[z.c+3]
+	b3 = z.b[z.c+2]
+	b2 = z.b[z.c+1]
+	b1 = z.b[z.c]
+	z.c += 4
+	z.a -= 4
+	return
+}
+
+// func (z *bytesDecReader) readn1eof() (v uint8, eof bool) {
+// 	if z.a == 0 {
+// 		eof = true
+// 		return
+// 	}
+// 	v = z.b[z.c]
+// 	z.c++
+// 	z.a--
+// 	return
+// }
+
+func (z *bytesDecReader) skip(accept *bitset256) (token byte) {
+	if z.a == 0 {
+		return
+	}
+	blen := len(z.b)
+	for i := z.c; i < blen; i++ {
+		if !accept.isset(z.b[i]) {
+			token = z.b[i]
+			i++
+			z.a -= (i - z.c)
+			z.c = i
+			return
+		}
+	}
+	z.a, z.c = 0, blen
+	return
+}
+
+func (z *bytesDecReader) readTo(_ []byte, accept *bitset256) (out []byte) {
+	if z.a == 0 {
+		return
+	}
+	blen := len(z.b)
+	for i := z.c; i < blen; i++ {
+		if !accept.isset(z.b[i]) {
+			out = z.b[z.c:i]
+			z.a -= (i - z.c)
+			z.c = i
+			return
+		}
+	}
+	out = z.b[z.c:]
+	z.a, z.c = 0, blen
+	return
+}
+
+func (z *bytesDecReader) readUntil(_ []byte, stop byte) (out []byte) {
+	if z.a == 0 {
+		panic(io.EOF)
+	}
+	blen := len(z.b)
+	for i := z.c; i < blen; i++ {
+		if z.b[i] == stop {
+			i++
+			out = z.b[z.c:i]
+			z.a -= (i - z.c)
+			z.c = i
+			return
+		}
+	}
+	z.a, z.c = 0, blen
+	panic(io.EOF)
 }
 
 func (z *bytesDecReader) track() {
@@ -419,44 +934,25 @@ func (z *bytesDecReader) stopTrack() (bs []byte) {
 	return z.b[z.t:z.c]
 }
 
-// ------------------------------------
-
-type decFnInfo struct {
-	d     *Decoder
-	ti    *typeInfo
-	xfFn  Ext
-	xfTag uint64
-	seq   seqType
-}
-
 // ----------------------------------------
 
-type decFn struct {
-	i decFnInfo
-	f func(*decFnInfo, reflect.Value)
+func (d *Decoder) builtin(f *codecFnInfo, rv reflect.Value) {
+	d.d.DecodeBuiltin(f.ti.rtid, rv2i(rv))
 }
 
-func (f *decFnInfo) builtin(rv reflect.Value) {
-	f.d.d.DecodeBuiltin(f.ti.rtid, rv.Addr().Interface())
+func (d *Decoder) rawExt(f *codecFnInfo, rv reflect.Value) {
+	d.d.DecodeExt(rv2i(rv), 0, nil)
 }
 
-func (f *decFnInfo) rawExt(rv reflect.Value) {
-	f.d.d.DecodeExt(rv.Addr().Interface(), 0, nil)
+func (d *Decoder) ext(f *codecFnInfo, rv reflect.Value) {
+	d.d.DecodeExt(rv2i(rv), f.xfTag, f.xfFn)
 }
 
-func (f *decFnInfo) raw(rv reflect.Value) {
-	rv.SetBytes(f.d.raw())
-}
-
-func (f *decFnInfo) ext(rv reflect.Value) {
-	f.d.d.DecodeExt(rv.Addr().Interface(), f.xfTag, f.xfFn)
-}
-
-func (f *decFnInfo) getValueForUnmarshalInterface(rv reflect.Value, indir int8) (v interface{}) {
+func (d *Decoder) getValueForUnmarshalInterface(rv reflect.Value, indir int8) (v interface{}) {
 	if indir == -1 {
-		v = rv.Addr().Interface()
+		v = rv2i(rv.Addr())
 	} else if indir == 0 {
-		v = rv.Interface()
+		v = rv2i(rv)
 	} else {
 		for j := int8(0); j < indir; j++ {
 			if rv.IsNil() {
@@ -464,122 +960,53 @@ func (f *decFnInfo) getValueForUnmarshalInterface(rv reflect.Value, indir int8)
 			}
 			rv = rv.Elem()
 		}
-		v = rv.Interface()
+		v = rv2i(rv)
 	}
 	return
 }
 
-func (f *decFnInfo) selferUnmarshal(rv reflect.Value) {
-	f.getValueForUnmarshalInterface(rv, f.ti.csIndir).(Selfer).CodecDecodeSelf(f.d)
+func (d *Decoder) selferUnmarshal(f *codecFnInfo, rv reflect.Value) {
+	d.getValueForUnmarshalInterface(rv, f.ti.csIndir).(Selfer).CodecDecodeSelf(d)
 }
 
-func (f *decFnInfo) binaryUnmarshal(rv reflect.Value) {
-	bm := f.getValueForUnmarshalInterface(rv, f.ti.bunmIndir).(encoding.BinaryUnmarshaler)
-	xbs := f.d.d.DecodeBytes(nil, false, true)
+func (d *Decoder) binaryUnmarshal(f *codecFnInfo, rv reflect.Value) {
+	bm := d.getValueForUnmarshalInterface(rv, f.ti.bunmIndir).(encoding.BinaryUnmarshaler)
+	xbs := d.d.DecodeBytes(nil, true)
 	if fnerr := bm.UnmarshalBinary(xbs); fnerr != nil {
 		panic(fnerr)
 	}
 }
 
-func (f *decFnInfo) textUnmarshal(rv reflect.Value) {
-	tm := f.getValueForUnmarshalInterface(rv, f.ti.tunmIndir).(encoding.TextUnmarshaler)
-	fnerr := tm.UnmarshalText(f.d.d.DecodeBytes(f.d.b[:], true, true))
+func (d *Decoder) textUnmarshal(f *codecFnInfo, rv reflect.Value) {
+	tm := d.getValueForUnmarshalInterface(rv, f.ti.tunmIndir).(encoding.TextUnmarshaler)
+	fnerr := tm.UnmarshalText(d.d.DecodeStringAsBytes())
 	if fnerr != nil {
 		panic(fnerr)
 	}
 }
 
-func (f *decFnInfo) jsonUnmarshal(rv reflect.Value) {
-	tm := f.getValueForUnmarshalInterface(rv, f.ti.junmIndir).(jsonUnmarshaler)
-	// bs := f.d.d.DecodeBytes(f.d.b[:], true, true)
+func (d *Decoder) jsonUnmarshal(f *codecFnInfo, rv reflect.Value) {
+	tm := d.getValueForUnmarshalInterface(rv, f.ti.junmIndir).(jsonUnmarshaler)
+	// bs := d.d.DecodeBytes(d.b[:], true, true)
 	// grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself.
-	fnerr := tm.UnmarshalJSON(f.d.nextValueBytes())
+	fnerr := tm.UnmarshalJSON(d.nextValueBytes())
 	if fnerr != nil {
 		panic(fnerr)
 	}
 }
 
-func (f *decFnInfo) kErr(rv reflect.Value) {
-	f.d.errorf("no decoding function defined for kind %v", rv.Kind())
+func (d *Decoder) kErr(f *codecFnInfo, rv reflect.Value) {
+	d.errorf("no decoding function defined for kind %v", rv.Kind())
 }
 
-func (f *decFnInfo) kString(rv reflect.Value) {
-	rv.SetString(f.d.d.DecodeString())
-}
-
-func (f *decFnInfo) kBool(rv reflect.Value) {
-	rv.SetBool(f.d.d.DecodeBool())
-}
-
-func (f *decFnInfo) kInt(rv reflect.Value) {
-	rv.SetInt(f.d.d.DecodeInt(intBitsize))
-}
-
-func (f *decFnInfo) kInt64(rv reflect.Value) {
-	rv.SetInt(f.d.d.DecodeInt(64))
-}
-
-func (f *decFnInfo) kInt32(rv reflect.Value) {
-	rv.SetInt(f.d.d.DecodeInt(32))
-}
-
-func (f *decFnInfo) kInt8(rv reflect.Value) {
-	rv.SetInt(f.d.d.DecodeInt(8))
-}
-
-func (f *decFnInfo) kInt16(rv reflect.Value) {
-	rv.SetInt(f.d.d.DecodeInt(16))
-}
-
-func (f *decFnInfo) kFloat32(rv reflect.Value) {
-	rv.SetFloat(f.d.d.DecodeFloat(true))
-}
-
-func (f *decFnInfo) kFloat64(rv reflect.Value) {
-	rv.SetFloat(f.d.d.DecodeFloat(false))
-}
-
-func (f *decFnInfo) kUint8(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(8))
-}
-
-func (f *decFnInfo) kUint64(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(64))
-}
-
-func (f *decFnInfo) kUint(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(uintBitsize))
-}
-
-func (f *decFnInfo) kUintptr(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(uintBitsize))
-}
-
-func (f *decFnInfo) kUint32(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(32))
-}
-
-func (f *decFnInfo) kUint16(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(16))
-}
-
-// func (f *decFnInfo) kPtr(rv reflect.Value) {
-// 	debugf(">>>>>>> ??? decode kPtr called - shouldn't get called")
-// 	if rv.IsNil() {
-// 		rv.Set(reflect.New(rv.Type().Elem()))
-// 	}
-// 	f.d.decodeValue(rv.Elem())
-// }
-
 // var kIntfCtr uint64
 
-func (f *decFnInfo) kInterfaceNaked() (rvn reflect.Value) {
+func (d *Decoder) kInterfaceNaked(f *codecFnInfo) (rvn reflect.Value) {
 	// nil interface:
 	// use some hieristics to decode it appropriately
 	// based on the detected next value in the stream.
-	d := f.d
+	n := d.naked()
 	d.d.DecodeNaked()
-	n := &d.n
 	if n.v == valueTypeNil {
 		return
 	}
@@ -592,264 +1019,277 @@ func (f *decFnInfo) kInterfaceNaked() (rvn reflect.Value) {
 	// var useRvn bool
 	switch n.v {
 	case valueTypeMap:
-		// if d.h.MapType == nil || d.h.MapType == mapIntfIntfTyp {
-		// } else if d.h.MapType == mapStrIntfTyp { // for json performance
-		// }
 		if d.mtid == 0 || d.mtid == mapIntfIntfTypId {
-			l := len(n.ms)
-			n.ms = append(n.ms, nil)
-			var v2 interface{} = &n.ms[l]
-			d.decode(v2)
-			rvn = reflect.ValueOf(v2).Elem()
-			n.ms = n.ms[:l]
+			if n.lm < arrayCacheLen {
+				n.ma[n.lm] = nil
+				rvn = n.rr[decNakedMapIntfIntfIdx*arrayCacheLen+n.lm]
+				n.lm++
+				d.decode(&n.ma[n.lm-1])
+				n.lm--
+			} else {
+				var v2 map[interface{}]interface{}
+				d.decode(&v2)
+				rvn = reflect.ValueOf(&v2).Elem()
+			}
 		} else if d.mtid == mapStrIntfTypId { // for json performance
-			l := len(n.ns)
-			n.ns = append(n.ns, nil)
-			var v2 interface{} = &n.ns[l]
-			d.decode(v2)
-			rvn = reflect.ValueOf(v2).Elem()
-			n.ns = n.ns[:l]
-		} else {
-			rvn = reflect.New(d.h.MapType).Elem()
-			d.decodeValue(rvn, nil)
-		}
-	case valueTypeArray:
-		// if d.h.SliceType == nil || d.h.SliceType == intfSliceTyp {
-		if d.stid == 0 || d.stid == intfSliceTypId {
-			l := len(n.ss)
-			n.ss = append(n.ss, nil)
-			var v2 interface{} = &n.ss[l]
-			d.decode(v2)
-			n.ss = n.ss[:l]
-			rvn = reflect.ValueOf(v2).Elem()
-			if reflectArrayOfSupported && d.stid == 0 && d.h.PreferArrayOverSlice {
-				rvn = reflectArrayOf(rvn)
+			if n.ln < arrayCacheLen {
+				n.na[n.ln] = nil
+				rvn = n.rr[decNakedMapStrIntfIdx*arrayCacheLen+n.ln]
+				n.ln++
+				d.decode(&n.na[n.ln-1])
+				n.ln--
+			} else {
+				var v2 map[string]interface{}
+				d.decode(&v2)
+				rvn = reflect.ValueOf(&v2).Elem()
 			}
 		} else {
-			rvn = reflect.New(d.h.SliceType).Elem()
-			d.decodeValue(rvn, nil)
+			rvn = reflect.New(d.h.MapType)
+			if useLookupRecognizedTypes && d.mtr { // isRecognizedRtid(d.mtid) {
+				d.decode(rv2i(rvn))
+				rvn = rvn.Elem()
+			} else {
+				rvn = rvn.Elem()
+				d.decodeValue(rvn, nil, false, true)
+			}
+		}
+	case valueTypeArray:
+		if d.stid == 0 || d.stid == intfSliceTypId {
+			if n.ls < arrayCacheLen {
+				n.sa[n.ls] = nil
+				rvn = n.rr[decNakedSliceIntfIdx*arrayCacheLen+n.ls]
+				n.ls++
+				d.decode(&n.sa[n.ls-1])
+				n.ls--
+			} else {
+				var v2 []interface{}
+				d.decode(&v2)
+				rvn = reflect.ValueOf(&v2).Elem()
+			}
+			if reflectArrayOfSupported && d.stid == 0 && d.h.PreferArrayOverSlice {
+				rvn2 := reflect.New(reflectArrayOf(rvn.Len(), intfTyp)).Elem()
+				reflect.Copy(rvn2, rvn)
+				rvn = rvn2
+			}
+		} else {
+			rvn = reflect.New(d.h.SliceType)
+			if useLookupRecognizedTypes && d.str { // isRecognizedRtid(d.stid) {
+				d.decode(rv2i(rvn))
+				rvn = rvn.Elem()
+			} else {
+				rvn = rvn.Elem()
+				d.decodeValue(rvn, nil, false, true)
+			}
 		}
 	case valueTypeExt:
 		var v interface{}
 		tag, bytes := n.u, n.l // calling decode below might taint the values
 		if bytes == nil {
-			l := len(n.is)
-			n.is = append(n.is, nil)
-			v2 := &n.is[l]
-			d.decode(v2)
-			v = *v2
-			n.is = n.is[:l]
+			if n.li < arrayCacheLen {
+				n.ia[n.li] = nil
+				n.li++
+				d.decode(&n.ia[n.li-1])
+				// v = *(&n.ia[l])
+				n.li--
+				v = n.ia[n.li]
+				n.ia[n.li] = nil
+			} else {
+				d.decode(&v)
+			}
 		}
 		bfn := d.h.getExtForTag(tag)
 		if bfn == nil {
 			var re RawExt
 			re.Tag = tag
 			re.Data = detachZeroCopyBytes(d.bytes, nil, bytes)
-			rvn = reflect.ValueOf(re)
+			re.Value = v
+			rvn = reflect.ValueOf(&re).Elem()
 		} else {
 			rvnA := reflect.New(bfn.rt)
-			rvn = rvnA.Elem()
 			if bytes != nil {
-				bfn.ext.ReadExt(rvnA.Interface(), bytes)
+				bfn.ext.ReadExt(rv2i(rvnA), bytes)
 			} else {
-				bfn.ext.UpdateExt(rvnA.Interface(), v)
+				bfn.ext.UpdateExt(rv2i(rvnA), v)
 			}
+			rvn = rvnA.Elem()
 		}
 	case valueTypeNil:
 		// no-op
 	case valueTypeInt:
-		rvn = reflect.ValueOf(&n.i).Elem()
+		rvn = n.rr[decNakedIntIdx] // d.np.get(&n.i)
 	case valueTypeUint:
-		rvn = reflect.ValueOf(&n.u).Elem()
+		rvn = n.rr[decNakedUintIdx] // d.np.get(&n.u)
 	case valueTypeFloat:
-		rvn = reflect.ValueOf(&n.f).Elem()
+		rvn = n.rr[decNakedFloatIdx] // d.np.get(&n.f)
 	case valueTypeBool:
-		rvn = reflect.ValueOf(&n.b).Elem()
+		rvn = n.rr[decNakedBoolIdx] // d.np.get(&n.b)
 	case valueTypeString, valueTypeSymbol:
-		rvn = reflect.ValueOf(&n.s).Elem()
+		rvn = n.rr[decNakedStringIdx] // d.np.get(&n.s)
 	case valueTypeBytes:
-		rvn = reflect.ValueOf(&n.l).Elem()
+		rvn = n.rr[decNakedBytesIdx] // d.np.get(&n.l)
 	case valueTypeTimestamp:
-		rvn = reflect.ValueOf(&n.t).Elem()
+		rvn = n.rr[decNakedTimeIdx] // d.np.get(&n.t)
 	default:
 		panic(fmt.Errorf("kInterfaceNaked: unexpected valueType: %d", n.v))
 	}
 	return
 }
 
-func (f *decFnInfo) kInterface(rv reflect.Value) {
-	// debugf("\t===> kInterface")
-
+func (d *Decoder) kInterface(f *codecFnInfo, rv reflect.Value) {
 	// Note:
 	// A consequence of how kInterface works, is that
 	// if an interface already contains something, we try
 	// to decode into what was there before.
 	// We do not replace with a generic value (as got from decodeNaked).
 
+	// every interface passed here MUST be settable.
 	var rvn reflect.Value
 	if rv.IsNil() {
-		rvn = f.kInterfaceNaked()
-		if rvn.IsValid() {
+		if rvn = d.kInterfaceNaked(f); rvn.IsValid() {
 			rv.Set(rvn)
 		}
-	} else if f.d.h.InterfaceReset {
-		rvn = f.kInterfaceNaked()
-		if rvn.IsValid() {
+		return
+	}
+	if d.h.InterfaceReset {
+		if rvn = d.kInterfaceNaked(f); rvn.IsValid() {
 			rv.Set(rvn)
 		} else {
 			// reset to zero value based on current type in there.
 			rv.Set(reflect.Zero(rv.Elem().Type()))
 		}
-	} else {
-		rvn = rv.Elem()
-		// Note: interface{} is settable, but underlying type may not be.
-		// Consequently, we have to set the reflect.Value directly.
-		// if underlying type is settable (e.g. ptr or interface),
-		// we just decode into it.
-		// Else we create a settable value, decode into it, and set on the interface.
-		if rvn.CanSet() {
-			f.d.decodeValue(rvn, nil)
-		} else {
-			rvn2 := reflect.New(rvn.Type()).Elem()
-			rvn2.Set(rvn)
-			f.d.decodeValue(rvn2, nil)
-			rv.Set(rvn2)
-		}
+		return
 	}
+
+	// now we have a non-nil interface value, meaning it contains a type
+	rvn = rv.Elem()
+	if d.d.TryDecodeAsNil() {
+		rv.Set(reflect.Zero(rvn.Type()))
+		return
+	}
+
+	// Note: interface{} is settable, but underlying type may not be.
+	// Consequently, we MAY have to create a decodable value out of the underlying value,
+	// decode into it, and reset the interface itself.
+	// fmt.Printf(">>>> kInterface: rvn type: %v, rv type: %v\n", rvn.Type(), rv.Type())
+
+	rvn2, canDecode := isDecodeable(rvn)
+	if canDecode {
+		d.decodeValue(rvn2, nil, true, true)
+		return
+	}
+
+	rvn2 = reflect.New(rvn.Type()).Elem()
+	rvn2.Set(rvn)
+	d.decodeValue(rvn2, nil, true, true)
+	rv.Set(rvn2)
 }
 
-func (f *decFnInfo) kStruct(rv reflect.Value) {
+func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) {
+	// checking if recognized within kstruct is too expensive.
+	// only check where you can determine if valid outside the loop
+	// ie on homogenous collections: slices, arrays and maps.
+	//
+	// if true, we don't create too many decFn's.
+	// It's a delicate balance.
+	const checkRecognized bool = false // false: TODO
+
 	fti := f.ti
-	d := f.d
 	dd := d.d
-	cr := d.cr
+	elemsep := d.hh.hasElemSeparators()
+	sfn := structFieldNode{v: rv, update: true}
 	ctyp := dd.ContainerType()
 	if ctyp == valueTypeMap {
 		containerLen := dd.ReadMapStart()
 		if containerLen == 0 {
-			if cr != nil {
-				cr.sendContainerState(containerMapEnd)
-			}
+			dd.ReadMapEnd()
 			return
 		}
 		tisfi := fti.sfi
 		hasLen := containerLen >= 0
-		if hasLen {
-			for j := 0; j < containerLen; j++ {
-				// rvkencname := dd.DecodeString()
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				rvkencname := stringView(dd.DecodeBytes(f.d.b[:], true, true))
-				// rvksi := ti.getForEncName(rvkencname)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				if k := fti.indexForEncName(rvkencname); k > -1 {
-					si := tisfi[k]
-					if dd.TryDecodeAsNil() {
-						si.setToZeroValue(rv)
-					} else {
-						d.decodeValue(si.field(rv, true), nil)
-					}
-				} else {
-					d.structFieldNotFound(-1, rvkencname)
-				}
+
+		for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+			// rvkencname := dd.DecodeString()
+			if elemsep {
+				dd.ReadMapElemKey()
 			}
-		} else {
-			for j := 0; !dd.CheckBreak(); j++ {
-				// rvkencname := dd.DecodeString()
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				rvkencname := stringView(dd.DecodeBytes(f.d.b[:], true, true))
-				// rvksi := ti.getForEncName(rvkencname)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				if k := fti.indexForEncName(rvkencname); k > -1 {
-					si := tisfi[k]
-					if dd.TryDecodeAsNil() {
-						si.setToZeroValue(rv)
-					} else {
-						d.decodeValue(si.field(rv, true), nil)
-					}
-				} else {
-					d.structFieldNotFound(-1, rvkencname)
-				}
+			rvkencnameB := dd.DecodeStringAsBytes()
+			rvkencname := stringView(rvkencnameB)
+			// rvksi := ti.getForEncName(rvkencname)
+			if elemsep {
+				dd.ReadMapElemValue()
 			}
+			if k := fti.indexForEncName(rvkencname); k > -1 {
+				si := tisfi[k]
+				if dd.TryDecodeAsNil() {
+					si.setToZeroValue(rv)
+				} else {
+					d.decodeValue(sfn.field(si), nil, checkRecognized, true)
+				}
+			} else {
+				d.structFieldNotFound(-1, rvkencname)
+			}
+			// keepAlive4StringView(rvkencnameB) // maintain ref 4 stringView // not needed, as reference is outside loop
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 	} else if ctyp == valueTypeArray {
 		containerLen := dd.ReadArrayStart()
 		if containerLen == 0 {
-			if cr != nil {
-				cr.sendContainerState(containerArrayEnd)
-			}
+			dd.ReadArrayEnd()
 			return
 		}
 		// Not much gain from doing it two ways for array.
 		// Arrays are not used as much for structs.
 		hasLen := containerLen >= 0
 		for j, si := range fti.sfip {
-			if hasLen {
-				if j == containerLen {
-					break
-				}
-			} else if dd.CheckBreak() {
+			if (hasLen && j == containerLen) || (!hasLen && dd.CheckBreak()) {
 				break
 			}
-			if cr != nil {
-				cr.sendContainerState(containerArrayElem)
+			if elemsep {
+				dd.ReadArrayElem()
 			}
 			if dd.TryDecodeAsNil() {
 				si.setToZeroValue(rv)
 			} else {
-				d.decodeValue(si.field(rv, true), nil)
+				d.decodeValue(sfn.field(si), nil, checkRecognized, true)
 			}
 		}
 		if containerLen > len(fti.sfip) {
 			// read remaining values and throw away
 			for j := len(fti.sfip); j < containerLen; j++ {
-				if cr != nil {
-					cr.sendContainerState(containerArrayElem)
+				if elemsep {
+					dd.ReadArrayElem()
 				}
 				d.structFieldNotFound(j, "")
 			}
 		}
-		if cr != nil {
-			cr.sendContainerState(containerArrayEnd)
-		}
+		dd.ReadArrayEnd()
 	} else {
-		f.d.error(onlyMapOrArrayCanDecodeIntoStructErr)
+		d.error(onlyMapOrArrayCanDecodeIntoStructErr)
 		return
 	}
 }
 
-func (f *decFnInfo) kSlice(rv reflect.Value) {
+func (d *Decoder) kSlice(f *codecFnInfo, rv reflect.Value) {
 	// A slice can be set from a map or array in stream.
 	// This way, the order can be kept (as order is lost with map).
 	ti := f.ti
-	d := f.d
 	dd := d.d
 	rtelem0 := ti.rt.Elem()
 	ctyp := dd.ContainerType()
 	if ctyp == valueTypeBytes || ctyp == valueTypeString {
 		// you can only decode bytes or string in the stream into a slice or array of bytes
 		if !(ti.rtid == uint8SliceTypId || rtelem0.Kind() == reflect.Uint8) {
-			f.d.errorf("bytes or string in the stream must be decoded into a slice or array of bytes, not %v", ti.rt)
+			d.errorf("bytes or string in the stream must be decoded into a slice or array of bytes, not %v", ti.rt)
 		}
 		if f.seq == seqTypeChan {
-			bs2 := dd.DecodeBytes(nil, false, true)
-			ch := rv.Interface().(chan<- byte)
+			bs2 := dd.DecodeBytes(nil, true)
+			ch := rv2i(rv).(chan<- byte)
 			for _, b := range bs2 {
 				ch <- b
 			}
 		} else {
 			rvbs := rv.Bytes()
-			bs2 := dd.DecodeBytes(rvbs, false, false)
+			bs2 := dd.DecodeBytes(rvbs, false)
 			if rvbs == nil && bs2 != nil || rvbs != nil && bs2 == nil || len(bs2) != len(rvbs) {
 				if rv.CanSet() {
 					rv.SetBytes(bs2)
@@ -865,155 +1305,182 @@ func (f *decFnInfo) kSlice(rv reflect.Value) {
 
 	slh, containerLenS := d.decSliceHelperStart() // only expects valueType(Array|Map)
 
-	// // an array can never return a nil slice. so no need to check f.array here.
+	// an array can never return a nil slice. so no need to check f.array here.
 	if containerLenS == 0 {
-		if f.seq == seqTypeSlice {
-			if rv.IsNil() {
-				rv.Set(reflect.MakeSlice(ti.rt, 0, 0))
-			} else {
-				rv.SetLen(0)
-			}
-		} else if f.seq == seqTypeChan {
-			if rv.IsNil() {
-				rv.Set(reflect.MakeChan(ti.rt, 0))
+		if rv.CanSet() {
+			if f.seq == seqTypeSlice {
+				if rv.IsNil() {
+					rv.Set(reflect.MakeSlice(ti.rt, 0, 0))
+				} else {
+					rv.SetLen(0)
+				}
+			} else if f.seq == seqTypeChan {
+				if rv.IsNil() {
+					rv.Set(reflect.MakeChan(ti.rt, 0))
+				}
 			}
 		}
 		slh.End()
 		return
 	}
 
+	rtelem0Size := int(rtelem0.Size())
+	rtElem0Kind := rtelem0.Kind()
+	rtElem0Id := rt2id(rtelem0)
+	rtelem0Mut := !isImmutableKind(rtElem0Kind)
 	rtelem := rtelem0
-	for rtelem.Kind() == reflect.Ptr {
+	rtelemkind := rtelem.Kind()
+	for rtelemkind == reflect.Ptr {
 		rtelem = rtelem.Elem()
+		rtelemkind = rtelem.Kind()
 	}
-	fn := d.getDecFn(rtelem, true, true)
+
+	var fn *codecFn
 
 	var rv0, rv9 reflect.Value
 	rv0 = rv
 	rvChanged := false
 
-	// for j := 0; j < containerLenS; j++ {
-	var rvlen int
-	if containerLenS > 0 { // hasLen
-		if f.seq == seqTypeChan {
-			if rv.IsNil() {
-				rvlen, _ = decInferLen(containerLenS, f.d.h.MaxInitLen, int(rtelem0.Size()))
-				rv.Set(reflect.MakeChan(ti.rt, rvlen))
-			}
-			// handle chan specially:
-			for j := 0; j < containerLenS; j++ {
-				rv9 = reflect.New(rtelem0).Elem()
-				slh.ElemContainerState(j)
-				d.decodeValue(rv9, fn)
-				rv.Send(rv9)
-			}
-		} else { // slice or array
-			var truncated bool         // says len of sequence is not same as expected number of elements
-			numToRead := containerLenS // if truncated, reset numToRead
-
-			rvcap := rv.Cap()
-			rvlen = rv.Len()
-			if containerLenS > rvcap {
-				if f.seq == seqTypeArray {
-					d.arrayCannotExpand(rvlen, containerLenS)
+	rvlen := rv.Len()
+	rvcap := rv.Cap()
+	hasLen := containerLenS > 0
+	if hasLen && f.seq == seqTypeSlice {
+		if containerLenS > rvcap {
+			oldRvlenGtZero := rvlen > 0
+			rvlen = decInferLen(containerLenS, d.h.MaxInitLen, int(rtelem0.Size()))
+			if rvlen <= rvcap {
+				if rv.CanSet() {
+					rv.SetLen(rvlen)
 				} else {
-					oldRvlenGtZero := rvlen > 0
-					rvlen, truncated = decInferLen(containerLenS, f.d.h.MaxInitLen, int(rtelem0.Size()))
-					if truncated {
-						if rvlen <= rvcap {
-							rv.SetLen(rvlen)
-						} else {
-							rv = reflect.MakeSlice(ti.rt, rvlen, rvlen)
-							rvChanged = true
-						}
-					} else {
-						rv = reflect.MakeSlice(ti.rt, rvlen, rvlen)
-						rvChanged = true
-					}
-					if rvChanged && oldRvlenGtZero && !isImmutableKind(rtelem0.Kind()) {
-						reflect.Copy(rv, rv0) // only copy up to length NOT cap i.e. rv0.Slice(0, rvcap)
-					}
-					rvcap = rvlen
+					rv = rv.Slice(0, rvlen)
+					rvChanged = true
 				}
-				numToRead = rvlen
-			} else if containerLenS != rvlen {
-				if f.seq == seqTypeSlice {
-					rv.SetLen(containerLenS)
-					rvlen = containerLenS
-				}
-			}
-			j := 0
-			// we read up to the numToRead
-			for ; j < numToRead; j++ {
-				slh.ElemContainerState(j)
-				d.decodeValue(rv.Index(j), fn)
-			}
-
-			// if slice, expand and read up to containerLenS (or EOF) iff truncated
-			// if array, swallow all the rest.
-
-			if f.seq == seqTypeArray {
-				for ; j < containerLenS; j++ {
-					slh.ElemContainerState(j)
-					d.swallow()
-				}
-			} else if truncated { // slice was truncated, as chan NOT in this block
-				for ; j < containerLenS; j++ {
-					rv = expandSliceValue(rv, 1)
-					rv9 = rv.Index(j)
-					if resetSliceElemToZeroValue {
-						rv9.Set(reflect.Zero(rtelem0))
-					}
-					slh.ElemContainerState(j)
-					d.decodeValue(rv9, fn)
-				}
-			}
-		}
-	} else {
-		rvlen = rv.Len()
-		j := 0
-		for ; !dd.CheckBreak(); j++ {
-			if f.seq == seqTypeChan {
-				slh.ElemContainerState(j)
-				rv9 = reflect.New(rtelem0).Elem()
-				d.decodeValue(rv9, fn)
-				rv.Send(rv9)
 			} else {
-				// if indefinite, etc, then expand the slice if necessary
-				var decodeIntoBlank bool
-				if j >= rvlen {
-					if f.seq == seqTypeArray {
-						d.arrayCannotExpand(rvlen, j+1)
-						decodeIntoBlank = true
-					} else { // if f.seq == seqTypeSlice
-						// rv = reflect.Append(rv, reflect.Zero(rtelem0)) // uses append logic, plus varargs
-						rv = expandSliceValue(rv, 1)
-						rv9 = rv.Index(j)
-						// rv.Index(rv.Len() - 1).Set(reflect.Zero(rtelem0))
-						if resetSliceElemToZeroValue {
-							rv9.Set(reflect.Zero(rtelem0))
-						}
-						rvlen++
-						rvChanged = true
-					}
-				} else { // slice or array
-					rv9 = rv.Index(j)
-				}
-				slh.ElemContainerState(j)
-				if decodeIntoBlank {
-					d.swallow()
-				} else { // seqTypeSlice
-					d.decodeValue(rv9, fn)
-				}
-			}
-		}
-		if f.seq == seqTypeSlice {
-			if j < rvlen {
-				rv.SetLen(j)
-			} else if j == 0 && rv.IsNil() {
-				rv = reflect.MakeSlice(ti.rt, 0, 0)
+				rv = reflect.MakeSlice(ti.rt, rvlen, rvlen)
+				rvcap = rvlen
 				rvChanged = true
 			}
+			if rvChanged && oldRvlenGtZero && !isImmutableKind(rtelem0.Kind()) {
+				reflect.Copy(rv, rv0) // only copy up to length NOT cap i.e. rv0.Slice(0, rvcap)
+			}
+		} else if containerLenS != rvlen {
+			rvlen = containerLenS
+			if rv.CanSet() {
+				rv.SetLen(rvlen)
+			} else {
+				rv = rv.Slice(0, rvlen)
+				rvChanged = true
+			}
+		}
+	}
+
+	var recognizedRtid, recognizedRtidPtr bool
+	if useLookupRecognizedTypes {
+		recognizedRtid = isRecognizedRtid(rtElem0Id)
+		recognizedRtidPtr = isRecognizedRtidPtr(rtElem0Id)
+	}
+
+	// consider creating new element once, and just decoding into it.
+	var rtelem0Zero reflect.Value
+	var rtelem0ZeroValid bool
+	var decodeAsNil bool
+	var j int
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && (f.seq == seqTypeSlice || f.seq == seqTypeChan) && rv.IsNil() {
+			if hasLen {
+				rvlen = decInferLen(containerLenS, d.h.MaxInitLen, rtelem0Size)
+			} else {
+				rvlen = 8
+			}
+			if f.seq == seqTypeSlice {
+				rv = reflect.MakeSlice(ti.rt, rvlen, rvlen)
+				rvChanged = true
+			} else if f.seq == seqTypeChan {
+				rv.Set(reflect.MakeChan(ti.rt, rvlen))
+			}
+		}
+		slh.ElemContainerState(j)
+		decodeAsNil = dd.TryDecodeAsNil()
+		if f.seq == seqTypeChan {
+			if decodeAsNil {
+				rv.Send(reflect.Zero(rtelem0))
+				continue
+			}
+			if rtelem0Mut || !rv9.IsValid() { // || (rtElem0Kind == reflect.Ptr && rv9.IsNil()) {
+				rv9 = reflect.New(rtelem0).Elem()
+			}
+			if useLookupRecognizedTypes && (recognizedRtid || recognizedRtidPtr) {
+				d.decode(rv2i(rv9.Addr()))
+			} else {
+				if fn == nil {
+					fn = d.cf.get(rtelem, true, true)
+				}
+				d.decodeValue(rv9, fn, false, true)
+			}
+			rv.Send(rv9)
+		} else {
+			// if indefinite, etc, then expand the slice if necessary
+			var decodeIntoBlank bool
+			if j >= rvlen {
+				if f.seq == seqTypeArray {
+					d.arrayCannotExpand(rvlen, j+1)
+					decodeIntoBlank = true
+				} else { // if f.seq == seqTypeSlice
+					// rv = reflect.Append(rv, reflect.Zero(rtelem0)) // uses append logic, plus varargs
+					var rvcap2 int
+					rv9, rvcap2, rvChanged = decExpandSliceRV(rv, ti.rt, rtelem0Size, 1, rvlen, rvcap)
+					rvlen++
+					if rvChanged {
+						rv = rv9
+						rvcap = rvcap2
+					}
+				}
+			}
+			if decodeIntoBlank {
+				if !decodeAsNil {
+					d.swallow()
+				}
+			} else {
+				rv9 = rv.Index(j)
+				if d.h.SliceElementReset || decodeAsNil {
+					if !rtelem0ZeroValid {
+						rtelem0ZeroValid = true
+						rtelem0Zero = reflect.Zero(rtelem0)
+					}
+					rv9.Set(rtelem0Zero)
+				}
+				if decodeAsNil {
+					continue
+				}
+
+				if useLookupRecognizedTypes && recognizedRtid {
+					d.decode(rv2i(rv9.Addr()))
+				} else if useLookupRecognizedTypes && recognizedRtidPtr { // && !rv9.IsNil() {
+					if rv9.IsNil() {
+						rv9.Set(reflect.New(rtelem))
+					}
+					d.decode(rv2i(rv9))
+				} else {
+					if fn == nil {
+						fn = d.cf.get(rtelem, true, true)
+					}
+					d.decodeValue(rv9, fn, false, true)
+				}
+			}
+		}
+	}
+	if f.seq == seqTypeSlice {
+		if j < rvlen {
+			if rv.CanSet() {
+				rv.SetLen(j)
+			} else {
+				rv = rv.Slice(0, j)
+				rvChanged = true
+			}
+			rvlen = j
+		} else if j == 0 && rv.IsNil() {
+			rv = reflect.MakeSlice(ti.rt, 0, 0)
+			rvChanged = true
 		}
 	}
 	slh.End()
@@ -1023,41 +1490,48 @@ func (f *decFnInfo) kSlice(rv reflect.Value) {
 	}
 }
 
-func (f *decFnInfo) kArray(rv reflect.Value) {
-	// f.d.decodeValue(rv.Slice(0, rv.Len()))
-	f.kSlice(rv.Slice(0, rv.Len()))
-}
+// func (d *Decoder) kArray(f *codecFnInfo, rv reflect.Value) {
+// 	// d.decodeValueFn(rv.Slice(0, rv.Len()))
+// 	f.kSlice(rv.Slice(0, rv.Len()))
+// }
 
-func (f *decFnInfo) kMap(rv reflect.Value) {
-	d := f.d
+func (d *Decoder) kMap(f *codecFnInfo, rv reflect.Value) {
 	dd := d.d
 	containerLen := dd.ReadMapStart()
-	cr := d.cr
+	elemsep := d.hh.hasElemSeparators()
 	ti := f.ti
 	if rv.IsNil() {
-		rv.Set(reflect.MakeMap(ti.rt))
+		rv.Set(makeMapReflect(ti.rt, containerLen))
 	}
 
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return
 	}
 
 	ktype, vtype := ti.rt.Key(), ti.rt.Elem()
-	ktypeId := reflect.ValueOf(ktype).Pointer()
+	ktypeId := rt2id(ktype)
+	vtypeId := rt2id(vtype)
 	vtypeKind := vtype.Kind()
-	var keyFn, valFn *decFn
-	var xtyp reflect.Type
-	for xtyp = ktype; xtyp.Kind() == reflect.Ptr; xtyp = xtyp.Elem() {
+	var recognizedKtyp, recognizedVtyp, recognizedPtrKtyp, recognizedPtrVtyp bool
+	if useLookupRecognizedTypes {
+		recognizedKtyp = isRecognizedRtid(ktypeId)
+		recognizedVtyp = isRecognizedRtid(vtypeId)
+		recognizedPtrKtyp = isRecognizedRtidPtr(ktypeId)
+		recognizedPtrVtyp = isRecognizedRtidPtr(vtypeId)
 	}
-	keyFn = d.getDecFn(xtyp, true, true)
-	for xtyp = vtype; xtyp.Kind() == reflect.Ptr; xtyp = xtyp.Elem() {
+
+	var keyFn, valFn *codecFn
+	var ktypeLo, vtypeLo reflect.Type
+	for ktypeLo = ktype; ktypeLo.Kind() == reflect.Ptr; ktypeLo = ktypeLo.Elem() {
 	}
-	valFn = d.getDecFn(xtyp, true, true)
+
+	for vtypeLo = vtype; vtypeLo.Kind() == reflect.Ptr; vtypeLo = vtypeLo.Elem() {
+	}
+
 	var mapGet, mapSet bool
-	if !f.d.h.MapValueReset {
+	rvvImmut := isImmutableKind(vtypeKind)
+	if !d.h.MapValueReset {
 		// if pointer, mapGet = true
 		// if interface, mapGet = true if !DecodeNakedAlways (else false)
 		// if builtin, mapGet = false
@@ -1065,118 +1539,140 @@ func (f *decFnInfo) kMap(rv reflect.Value) {
 		if vtypeKind == reflect.Ptr {
 			mapGet = true
 		} else if vtypeKind == reflect.Interface {
-			if !f.d.h.InterfaceReset {
+			if !d.h.InterfaceReset {
 				mapGet = true
 			}
-		} else if !isImmutableKind(vtypeKind) {
+		} else if !rvvImmut {
 			mapGet = true
 		}
 	}
 
-	var rvk, rvv, rvz reflect.Value
-
-	// for j := 0; j < containerLen; j++ {
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			rvk = reflect.New(ktype).Elem()
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+	var rvk, rvkp, rvv, rvz reflect.Value
+	rvkMut := !isImmutableKind(ktype.Kind()) // if ktype is immutable, then re-use the same rvk.
+	ktypeIsString := ktypeId == stringTypId
+	ktypeIsIntf := ktypeId == intfTypId
+	hasLen := containerLen > 0
+	var kstrbs []byte
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if elemsep {
+			dd.ReadMapElemKey()
+		}
+		// if a nil key, just ignore the mapped value and continue
+		if dd.TryDecodeAsNil() {
+			if elemsep {
+				dd.ReadMapElemValue()
 			}
-			d.decodeValue(rvk, keyFn)
-
-			// special case if a byte array.
-			if ktypeId == intfTypId {
-				rvk = rvk.Elem()
-				if rvk.Type() == uint8SliceTyp {
-					rvk = reflect.ValueOf(d.string(rvk.Bytes()))
-				}
+			d.swallow()
+			continue
+		}
+		if rvkMut || !rvkp.IsValid() {
+			rvkp = reflect.New(ktype)
+			rvk = rvkp.Elem()
+		}
+		if ktypeIsString {
+			kstrbs = dd.DecodeStringAsBytes()
+			rvk.SetString(stringView(kstrbs))
+			// NOTE: if doing an insert, you MUST use a real string (not stringview)
+		} else if useLookupRecognizedTypes && recognizedKtyp {
+			d.decode(rv2i(rvkp))
+			// rvk = rvkp.Elem() //TODO: remove, unnecessary
+		} else if useLookupRecognizedTypes && recognizedPtrKtyp {
+			if rvk.IsNil() {
+				rvk = reflect.New(ktypeLo)
 			}
-			mapSet = true // set to false if u do a get, and its a pointer, and exists
-			if mapGet {
-				rvv = rv.MapIndex(rvk)
-				if rvv.IsValid() {
-					if vtypeKind == reflect.Ptr {
-						mapSet = false
-					}
-				} else {
-					if rvz.IsValid() {
-						rvz.Set(reflect.Zero(vtype))
-					} else {
-						rvz = reflect.New(vtype).Elem()
-					}
-					rvv = rvz
-				}
-			} else {
-				if rvz.IsValid() {
-					rvz.Set(reflect.Zero(vtype))
-				} else {
-					rvz = reflect.New(vtype).Elem()
-				}
-				rvv = rvz
+			d.decode(rv2i(rvk))
+		} else {
+			if keyFn == nil {
+				keyFn = d.cf.get(ktypeLo, true, true)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			d.decodeValue(rvv, valFn)
-			if mapSet {
-				rv.SetMapIndex(rvk, rvv)
+			d.decodeValue(rvk, keyFn, false, true)
+		}
+		// special case if a byte array.
+		if ktypeIsIntf {
+			rvk = rvk.Elem()
+			if rvk.Type() == uint8SliceTyp {
+				rvk = reflect.ValueOf(d.string(rvk.Bytes()))
 			}
 		}
-	} else {
-		for j := 0; !dd.CheckBreak(); j++ {
-			rvk = reflect.New(ktype).Elem()
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			d.decodeValue(rvk, keyFn)
 
-			// special case if a byte array.
-			if ktypeId == intfTypId {
-				rvk = rvk.Elem()
-				if rvk.Type() == uint8SliceTyp {
-					rvk = reflect.ValueOf(d.string(rvk.Bytes()))
-				}
-			}
-			mapSet = true // set to false if u do a get, and its a pointer, and exists
-			if mapGet {
-				rvv = rv.MapIndex(rvk)
-				if rvv.IsValid() {
-					if vtypeKind == reflect.Ptr {
-						mapSet = false
-					}
-				} else {
-					if rvz.IsValid() {
-						rvz.Set(reflect.Zero(vtype))
-					} else {
-						rvz = reflect.New(vtype).Elem()
-					}
-					rvv = rvz
-				}
-			} else {
-				if rvz.IsValid() {
-					rvz.Set(reflect.Zero(vtype))
-				} else {
-					rvz = reflect.New(vtype).Elem()
-				}
-				rvv = rvz
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			d.decodeValue(rvv, valFn)
-			if mapSet {
-				rv.SetMapIndex(rvk, rvv)
-			}
+		if elemsep {
+			dd.ReadMapElemValue()
 		}
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
 
-type decRtidFn struct {
-	rtid uintptr
-	fn   decFn
+		// Brittle, but OK per TryDecodeAsNil() contract.
+		// i.e. TryDecodeAsNil never shares slices with other decDriver procedures
+		if dd.TryDecodeAsNil() {
+			if ktypeIsString {
+				rvk.SetString(d.string(kstrbs))
+			}
+			if d.h.DeleteOnNilMapValue {
+				rv.SetMapIndex(rvk, reflect.Value{})
+			} else {
+				rv.SetMapIndex(rvk, reflect.Zero(vtype))
+			}
+			continue
+		}
+
+		mapSet = true // set to false if u do a get, and its a non-nil pointer
+		if mapGet {
+			// mapGet true only in case where kind=Ptr|Interface or kind is otherwise mutable.
+			rvv = rv.MapIndex(rvk)
+			if !rvv.IsValid() {
+				rvv = reflect.New(vtype).Elem()
+			} else if vtypeKind == reflect.Ptr {
+				if rvv.IsNil() {
+					rvv = reflect.New(vtype).Elem()
+				} else {
+					mapSet = false
+				}
+			} else if vtypeKind == reflect.Interface {
+				// not addressable, and thus not settable.
+				// e MUST create a settable/addressable variant
+				rvv2 := reflect.New(rvv.Type()).Elem()
+				if !rvv.IsNil() {
+					rvv2.Set(rvv)
+				}
+				rvv = rvv2
+			}
+			// else it is ~mutable, and we can just decode into it directly
+		} else if rvvImmut {
+			if !rvz.IsValid() {
+				rvz = reflect.New(vtype).Elem()
+			}
+			rvv = rvz
+		} else {
+			rvv = reflect.New(vtype).Elem()
+		}
+
+		// We MUST be done with the stringview of the key, before decoding the value
+		// so that we don't bastardize the reused byte array.
+		if mapSet && ktypeIsString {
+			rvk.SetString(d.string(kstrbs))
+		}
+		if useLookupRecognizedTypes && recognizedVtyp && rvv.CanAddr() {
+			d.decode(rv2i(rvv.Addr()))
+		} else if useLookupRecognizedTypes && recognizedPtrVtyp {
+			if rvv.IsNil() {
+				rvv = reflect.New(vtypeLo)
+				mapSet = true
+			}
+			d.decode(rv2i(rvv))
+		} else {
+			if valFn == nil {
+				valFn = d.cf.get(vtypeLo, true, true)
+			}
+			d.decodeValue(rvv, valFn, false, true)
+			// d.decodeValueFn(rvv, valFn)
+		}
+		if mapSet {
+			rv.SetMapIndex(rvk, rvv)
+		}
+		// if ktypeIsString {
+		// 	// keepAlive4StringView(kstrbs) // not needed, as reference is outside loop
+		// }
+	}
+
+	dd.ReadMapEnd()
 }
 
 // decNaked is used to keep track of the primitives decoded.
@@ -1205,37 +1701,80 @@ type decNaked struct {
 	l []byte
 	s string
 	t time.Time
+
 	b bool
+
+	inited bool
+
 	v valueType
 
-	// stacks for reducing allocation
-	is []interface{}
-	ms []map[interface{}]interface{}
-	ns []map[string]interface{}
-	ss [][]interface{}
-	// rs []RawExt
+	li, lm, ln, ls int8
 
+	// array/stacks for reducing allocation
 	// keep arrays at the bottom? Chance is that they are not used much.
-	ia [4]interface{}
-	ma [4]map[interface{}]interface{}
-	na [4]map[string]interface{}
-	sa [4][]interface{}
+	ia [arrayCacheLen]interface{}
+	ma [arrayCacheLen]map[interface{}]interface{}
+	na [arrayCacheLen]map[string]interface{}
+	sa [arrayCacheLen][]interface{}
 	// ra [2]RawExt
+
+	rr [5 * arrayCacheLen]reflect.Value
+}
+
+const (
+	decNakedUintIdx = iota
+	decNakedIntIdx
+	decNakedFloatIdx
+	decNakedBytesIdx
+	decNakedStringIdx
+	decNakedTimeIdx
+	decNakedBoolIdx
+)
+const (
+	_ = iota // maps to the scalars above
+	decNakedIntfIdx
+	decNakedMapIntfIntfIdx
+	decNakedMapStrIntfIdx
+	decNakedSliceIntfIdx
+)
+
+func (n *decNaked) init() {
+	if n.inited {
+		return
+	}
+	// n.ms = n.ma[:0]
+	// n.is = n.ia[:0]
+	// n.ns = n.na[:0]
+	// n.ss = n.sa[:0]
+
+	n.rr[decNakedUintIdx] = reflect.ValueOf(&n.u).Elem()
+	n.rr[decNakedIntIdx] = reflect.ValueOf(&n.i).Elem()
+	n.rr[decNakedFloatIdx] = reflect.ValueOf(&n.f).Elem()
+	n.rr[decNakedBytesIdx] = reflect.ValueOf(&n.l).Elem()
+	n.rr[decNakedStringIdx] = reflect.ValueOf(&n.s).Elem()
+	n.rr[decNakedTimeIdx] = reflect.ValueOf(&n.t).Elem()
+	n.rr[decNakedBoolIdx] = reflect.ValueOf(&n.b).Elem()
+
+	for i := range [arrayCacheLen]struct{}{} {
+		n.rr[decNakedIntfIdx*arrayCacheLen+i] = reflect.ValueOf(&(n.ia[i])).Elem()
+		n.rr[decNakedMapIntfIntfIdx*arrayCacheLen+i] = reflect.ValueOf(&(n.ma[i])).Elem()
+		n.rr[decNakedMapStrIntfIdx*arrayCacheLen+i] = reflect.ValueOf(&(n.na[i])).Elem()
+		n.rr[decNakedSliceIntfIdx*arrayCacheLen+i] = reflect.ValueOf(&(n.sa[i])).Elem()
+	}
+	n.inited = true
+	// n.rr[] = reflect.ValueOf(&n.)
 }
 
 func (n *decNaked) reset() {
-	if n.ss != nil {
-		n.ss = n.ss[:0]
-	}
-	if n.is != nil {
-		n.is = n.is[:0]
-	}
-	if n.ms != nil {
-		n.ms = n.ms[:0]
-	}
-	if n.ns != nil {
-		n.ns = n.ns[:0]
+	if n == nil {
+		return
 	}
+	n.li, n.lm, n.ln, n.ls = 0, 0, 0, 0
+}
+
+type rtid2rv struct {
+	rtid uintptr
+	rv   reflect.Value
 }
 
 // A Decoder reads and decodes an object from an input stream in the codec format.
@@ -1246,31 +1785,43 @@ type Decoder struct {
 	d decDriver
 	// NOTE: Decoder shouldn't call it's read methods,
 	// as the handler MAY need to do some coordination.
-	r decReader
-	// sa [initCollectionCap]decRtidFn
-	h  *BasicHandle
+	r  decReader
 	hh Handle
+	h  *BasicHandle
+
+	mtr, mtrp, str, strp bool //
 
 	be    bool // is binary encoding
 	bytes bool // is bytes reader
 	js    bool // is json handle
 
+	// ---- cpu cache line boundary?
+
 	rb bytesDecReader
 	ri ioDecReader
-	cr containerStateRecv
+	bi bufioDecReader
 
-	s []decRtidFn
-	f map[uintptr]*decFn
+	// cr containerStateRecv
 
-	// _  uintptr // for alignment purposes, so next one starts from a cache line
+	n   *decNaked
+	nsp *sync.Pool
+
+	// ---- cpu cache line boundary?
+
+	is map[string]string // used for interning strings
 
 	// cache the mapTypeId and sliceTypeId for faster comparisons
 	mtid uintptr
 	stid uintptr
 
-	n  decNaked
-	b  [scratchByteArrayLen]byte
-	is map[string]string // used for interning strings
+	b [scratchByteArrayLen]byte
+	// _  uintptr // for alignment purposes, so next one starts from a cache line
+
+	err error
+	// ---- cpu cache line boundary?
+
+	cf codecFner
+	// _ [64]byte // force alignment???
 }
 
 // NewDecoder returns a Decoder for decoding a stream of bytes from an io.Reader.
@@ -1291,64 +1842,87 @@ func NewDecoderBytes(in []byte, h Handle) *Decoder {
 	return d
 }
 
+var defaultDecNaked decNaked
+
 func newDecoder(h Handle) *Decoder {
 	d := &Decoder{hh: h, h: h.getBasicHandle(), be: h.isBinary()}
-	n := &d.n
-	// n.rs = n.ra[:0]
-	n.ms = n.ma[:0]
-	n.is = n.ia[:0]
-	n.ns = n.na[:0]
-	n.ss = n.sa[:0]
+
+	// NOTE: do not initialize d.n here. It is lazily initialized in d.naked()
+
 	_, d.js = h.(*JsonHandle)
 	if d.h.InternString {
 		d.is = make(map[string]string, 32)
 	}
 	d.d = h.newDecDriver(d)
-	d.cr, _ = d.d.(containerStateRecv)
-	// d.d = h.newDecDriver(decReaderT{true, &d.rb, &d.ri})
+	// d.cr, _ = d.d.(containerStateRecv)
 	return d
 }
 
+// naked must be called before each call to .DecodeNaked,
+// as they will use it.
+func (d *Decoder) naked() *decNaked {
+	if d.n == nil {
+		// consider one of:
+		//   - get from sync.Pool  (if GC is frequent, there's no value here)
+		//   - new alloc           (safest. only init'ed if it a naked decode will be done)
+		//   - field in Decoder    (makes the Decoder struct very big)
+		// To support using a decoder where a DecodeNaked is not needed,
+		// we prefer #1 or #2.
+		// d.n = new(decNaked) // &d.nv // new(decNaked) // grab from a sync.Pool
+		// d.n.init()
+		var v interface{}
+		d.nsp, v = pool.decNaked()
+		d.n = v.(*decNaked)
+	}
+	return d.n
+}
+
 func (d *Decoder) resetCommon() {
 	d.n.reset()
 	d.d.reset()
+	d.cf.reset(d.hh)
+	d.err = nil
 	// reset all things which were cached from the Handle,
 	// but could be changed.
 	d.mtid, d.stid = 0, 0
+	d.mtr, d.mtrp, d.str, d.strp = false, false, false, false
 	if d.h.MapType != nil {
-		d.mtid = reflect.ValueOf(d.h.MapType).Pointer()
+		d.mtid = rt2id(d.h.MapType)
+		if useLookupRecognizedTypes {
+			d.mtr = isRecognizedRtid(d.mtid)
+			d.mtrp = isRecognizedRtidPtr(d.mtid)
+		}
 	}
 	if d.h.SliceType != nil {
-		d.stid = reflect.ValueOf(d.h.SliceType).Pointer()
+		d.stid = rt2id(d.h.SliceType)
+		if useLookupRecognizedTypes {
+			d.str = isRecognizedRtid(d.stid)
+			d.strp = isRecognizedRtidPtr(d.stid)
+		}
 	}
 }
 
 func (d *Decoder) Reset(r io.Reader) {
-	d.ri.x = &d.b
-	// d.s = d.sa[:0]
-	d.ri.bs.r = r
-	var ok bool
-	d.ri.br, ok = r.(decReaderByteScanner)
-	if !ok {
-		d.ri.br = &d.ri.bs
+	if d.h.ReaderBufferSize > 0 {
+		d.bi.buf = make([]byte, 0, d.h.ReaderBufferSize)
+		d.bi.reset(r)
+		d.r = &d.bi
+	} else {
+		d.ri.x = &d.b
+		// d.s = d.sa[:0]
+		d.ri.reset(r)
+		d.r = &d.ri
 	}
-	d.r = &d.ri
 	d.resetCommon()
 }
 
 func (d *Decoder) ResetBytes(in []byte) {
-	// d.s = d.sa[:0]
+	d.bytes = true
 	d.rb.reset(in)
 	d.r = &d.rb
 	d.resetCommon()
 }
 
-// func (d *Decoder) sendContainerState(c containerState) {
-// 	if d.cr != nil {
-// 		d.cr.sendContainerState(c)
-// 	}
-// }
-
 // Decode decodes the stream from reader and stores the result in the
 // value pointed to by v. v cannot be a nil pointer. v can also be
 // a reflect.Value of a pointer.
@@ -1400,170 +1974,169 @@ func (d *Decoder) ResetBytes(in []byte) {
 // to its "zero" value (e.g. nil for slice/map, etc).
 //
 func (d *Decoder) Decode(v interface{}) (err error) {
-	defer panicToErr(&err)
-	d.decode(v)
+	defer panicToErrs2(&d.err, &err)
+	d.MustDecode(v)
 	return
 }
 
-// this is not a smart swallow, as it allocates objects and does unnecessary work.
-func (d *Decoder) swallowViaHammer() {
-	var blank interface{}
-	d.decodeValue(reflect.ValueOf(&blank).Elem(), nil)
+// MustDecode is like Decode, but panics if unable to Decode.
+// This provides insight to the code location that triggered the error.
+func (d *Decoder) MustDecode(v interface{}) {
+	// TODO: Top-level: ensure that v is a pointer and not nil.
+	if d.err != nil {
+		panic(d.err)
+	}
+	if d.d.TryDecodeAsNil() {
+		d.setZero(v)
+	} else {
+		d.decode(v)
+	}
+	if d.nsp != nil {
+		if d.n != nil {
+			d.nsp.Put(d.n)
+			d.n = nil
+		}
+		d.nsp = nil
+	}
+	d.n = nil
+	// xprintf(">>>>>>>> >>>>>>>> num decFns: %v\n", d.cf.sn)
 }
 
+// // this is not a smart swallow, as it allocates objects and does unnecessary work.
+// func (d *Decoder) swallowViaHammer() {
+// 	var blank interface{}
+// 	d.decodeValueNoFn(reflect.ValueOf(&blank).Elem())
+// }
+
 func (d *Decoder) swallow() {
 	// smarter decode that just swallows the content
 	dd := d.d
 	if dd.TryDecodeAsNil() {
 		return
 	}
-	cr := d.cr
+	elemsep := d.hh.hasElemSeparators()
 	switch dd.ContainerType() {
 	case valueTypeMap:
 		containerLen := dd.ReadMapStart()
-		clenGtEqualZero := containerLen >= 0
-		for j := 0; ; j++ {
-			if clenGtEqualZero {
-				if j >= containerLen {
-					break
-				}
-			} else if dd.CheckBreak() {
-				break
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		hasLen := containerLen >= 0
+		for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+			// if clenGtEqualZero {if j >= containerLen {break} } else if dd.CheckBreak() {break}
+			if elemsep {
+				dd.ReadMapElemKey()
 			}
 			d.swallow()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if elemsep {
+				dd.ReadMapElemValue()
 			}
 			d.swallow()
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 	case valueTypeArray:
-		containerLenS := dd.ReadArrayStart()
-		clenGtEqualZero := containerLenS >= 0
-		for j := 0; ; j++ {
-			if clenGtEqualZero {
-				if j >= containerLenS {
-					break
-				}
-			} else if dd.CheckBreak() {
-				break
-			}
-			if cr != nil {
-				cr.sendContainerState(containerArrayElem)
+		containerLen := dd.ReadArrayStart()
+		hasLen := containerLen >= 0
+		for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+			if elemsep {
+				dd.ReadArrayElem()
 			}
 			d.swallow()
 		}
-		if cr != nil {
-			cr.sendContainerState(containerArrayEnd)
-		}
+		dd.ReadArrayEnd()
 	case valueTypeBytes:
-		dd.DecodeBytes(d.b[:], false, true)
+		dd.DecodeBytes(d.b[:], true)
 	case valueTypeString:
-		dd.DecodeBytes(d.b[:], true, true)
-		// dd.DecodeStringAsBytes(d.b[:])
+		dd.DecodeStringAsBytes()
 	default:
 		// these are all primitives, which we can get from decodeNaked
 		// if RawExt using Value, complete the processing.
+		n := d.naked()
 		dd.DecodeNaked()
-		if n := &d.n; n.v == valueTypeExt && n.l == nil {
-			l := len(n.is)
-			n.is = append(n.is, nil)
-			v2 := &n.is[l]
-			d.decode(v2)
-			n.is = n.is[:l]
+		if n.v == valueTypeExt && n.l == nil {
+			if n.li < arrayCacheLen {
+				n.ia[n.li] = nil
+				n.li++
+				d.decode(&n.ia[n.li-1])
+				n.ia[n.li-1] = nil
+				n.li--
+			} else {
+				var v2 interface{}
+				d.decode(&v2)
+			}
 		}
 	}
 }
 
-// MustDecode is like Decode, but panics if unable to Decode.
-// This provides insight to the code location that triggered the error.
-func (d *Decoder) MustDecode(v interface{}) {
-	d.decode(v)
+func (d *Decoder) setZero(iv interface{}) {
+	if iv == nil || definitelyNil(iv) {
+		return
+	}
+	switch v := iv.(type) {
+	case *string:
+		*v = ""
+	case *bool:
+		*v = false
+	case *int:
+		*v = 0
+	case *int8:
+		*v = 0
+	case *int16:
+		*v = 0
+	case *int32:
+		*v = 0
+	case *int64:
+		*v = 0
+	case *uint:
+		*v = 0
+	case *uint8:
+		*v = 0
+	case *uint16:
+		*v = 0
+	case *uint32:
+		*v = 0
+	case *uint64:
+		*v = 0
+	case *float32:
+		*v = 0
+	case *float64:
+		*v = 0
+	case *[]uint8:
+		*v = nil
+	case *Raw:
+		*v = nil
+	case reflect.Value:
+		v = d.ensureDecodeable(v)
+		if v.CanSet() {
+			v.Set(reflect.Zero(v.Type()))
+		} // TODO: else drain if chan, clear if map, set all to nil if slice???
+	default:
+		if !fastpathDecodeSetZeroTypeSwitch(iv, d) {
+			v := reflect.ValueOf(iv)
+			v = d.ensureDecodeable(v)
+			if v.CanSet() {
+				v.Set(reflect.Zero(v.Type()))
+			} // TODO: else drain if chan, clear if map, set all to nil if slice???
+		}
+	}
 }
 
 func (d *Decoder) decode(iv interface{}) {
-	// if ics, ok := iv.(Selfer); ok {
-	// 	ics.CodecDecodeSelf(d)
-	// 	return
-	// }
-
-	if d.d.TryDecodeAsNil() {
-		switch v := iv.(type) {
-		case nil:
-		case *string:
-			*v = ""
-		case *bool:
-			*v = false
-		case *int:
-			*v = 0
-		case *int8:
-			*v = 0
-		case *int16:
-			*v = 0
-		case *int32:
-			*v = 0
-		case *int64:
-			*v = 0
-		case *uint:
-			*v = 0
-		case *uint8:
-			*v = 0
-		case *uint16:
-			*v = 0
-		case *uint32:
-			*v = 0
-		case *uint64:
-			*v = 0
-		case *float32:
-			*v = 0
-		case *float64:
-			*v = 0
-		case *[]uint8:
-			*v = nil
-		case *Raw:
-			*v = nil
-		case reflect.Value:
-			if v.Kind() != reflect.Ptr || v.IsNil() {
-				d.errNotValidPtrValue(v)
-			}
-			// d.chkPtrValue(v)
-			v = v.Elem()
-			if v.IsValid() {
-				v.Set(reflect.Zero(v.Type()))
-			}
-		default:
-			rv := reflect.ValueOf(iv)
-			if rv.Kind() != reflect.Ptr || rv.IsNil() {
-				d.errNotValidPtrValue(rv)
-			}
-			// d.chkPtrValue(rv)
-			rv = rv.Elem()
-			if rv.IsValid() {
-				rv.Set(reflect.Zero(rv.Type()))
-			}
-		}
+	// check nil and interfaces explicitly,
+	// so that type switches just have a run of constant non-interface types.
+	if iv == nil {
+		d.error(cannotDecodeIntoNilErr)
+		return
+	}
+	if v, ok := iv.(Selfer); ok {
+		v.CodecDecodeSelf(d)
 		return
 	}
 
 	switch v := iv.(type) {
-	case nil:
-		d.error(cannotDecodeIntoNilErr)
-		return
-
-	case Selfer:
-		v.CodecDecodeSelf(d)
+	// case nil:
+	// case Selfer:
 
 	case reflect.Value:
-		if v.Kind() != reflect.Ptr || v.IsNil() {
-			d.errNotValidPtrValue(v)
-		}
-		// d.chkPtrValue(v)
-		d.decodeValueNotNil(v.Elem(), nil)
+		v = d.ensureDecodeable(v)
+		d.decodeValue(v, nil, false, true) // TODO: maybe ask to recognize ...
 
 	case *string:
 		*v = d.d.DecodeString()
@@ -1594,229 +2167,70 @@ func (d *Decoder) decode(iv interface{}) {
 	case *float64:
 		*v = d.d.DecodeFloat(false)
 	case *[]uint8:
-		*v = d.d.DecodeBytes(*v, false, false)
+		*v = d.d.DecodeBytes(*v, false)
 
 	case *Raw:
-		*v = d.raw()
+		*v = d.rawBytes()
 
 	case *interface{}:
-		d.decodeValueNotNil(reflect.ValueOf(iv).Elem(), nil)
+		d.decodeValue(reflect.ValueOf(iv).Elem(), nil, false, true) // TODO: consider recognize here
+		// d.decodeValueNotNil(reflect.ValueOf(iv).Elem())
 
 	default:
 		if !fastpathDecodeTypeSwitch(iv, d) {
-			d.decodeI(iv, true, false, false, false)
+			v := reflect.ValueOf(iv)
+			v = d.ensureDecodeable(v)
+			d.decodeValue(v, nil, false, false)
+			// d.decodeValueFallback(v)
 		}
 	}
 }
 
-func (d *Decoder) preDecodeValue(rv reflect.Value, tryNil bool) (rv2 reflect.Value, proceed bool) {
-	if tryNil && d.d.TryDecodeAsNil() {
-		// No need to check if a ptr, recursively, to determine
-		// whether to set value to nil.
-		// Just always set value to its zero type.
-		if rv.IsValid() { // rv.CanSet() // always settable, except it's invalid
-			rv.Set(reflect.Zero(rv.Type()))
-		}
-		return
-	}
-
+func (d *Decoder) decodeValue(rv reflect.Value, fn *codecFn, tryRecognized, chkAll bool) {
 	// If stream is not containing a nil value, then we can deref to the base
 	// non-pointer value, and decode into that.
-	for rv.Kind() == reflect.Ptr {
-		if rv.IsNil() {
-			rv.Set(reflect.New(rv.Type().Elem()))
-		}
-		rv = rv.Elem()
-	}
-	return rv, true
-}
-
-func (d *Decoder) decodeI(iv interface{}, checkPtr, tryNil, checkFastpath, checkCodecSelfer bool) {
-	rv := reflect.ValueOf(iv)
-	if checkPtr {
-		if rv.Kind() != reflect.Ptr || rv.IsNil() {
-			d.errNotValidPtrValue(rv)
-		}
-		// d.chkPtrValue(rv)
-	}
-	rv, proceed := d.preDecodeValue(rv, tryNil)
-	if proceed {
-		fn := d.getDecFn(rv.Type(), checkFastpath, checkCodecSelfer)
-		fn.f(&fn.i, rv)
-	}
-}
-
-func (d *Decoder) decodeValue(rv reflect.Value, fn *decFn) {
-	if rv, proceed := d.preDecodeValue(rv, true); proceed {
-		if fn == nil {
-			fn = d.getDecFn(rv.Type(), true, true)
-		}
-		fn.f(&fn.i, rv)
-	}
-}
-
-func (d *Decoder) decodeValueNotNil(rv reflect.Value, fn *decFn) {
-	if rv, proceed := d.preDecodeValue(rv, false); proceed {
-		if fn == nil {
-			fn = d.getDecFn(rv.Type(), true, true)
-		}
-		fn.f(&fn.i, rv)
-	}
-}
-
-func (d *Decoder) getDecFn(rt reflect.Type, checkFastpath, checkCodecSelfer bool) (fn *decFn) {
-	rtid := reflect.ValueOf(rt).Pointer()
-
-	// retrieve or register a focus'ed function for this type
-	// to eliminate need to do the retrieval multiple times
-
-	// if d.f == nil && d.s == nil { debugf("---->Creating new dec f map for type: %v\n", rt) }
-	var ok bool
-	if useMapForCodecCache {
-		fn, ok = d.f[rtid]
-	} else {
-		for i := range d.s {
-			v := &(d.s[i])
-			if v.rtid == rtid {
-				fn, ok = &(v.fn), true
+	var rvp reflect.Value
+	var rvpValid bool
+	if rv.Kind() == reflect.Ptr {
+		rvpValid = true
+		for {
+			if rv.IsNil() {
+				rv.Set(reflect.New(rv.Type().Elem()))
+			}
+			rvp = rv
+			rv = rv.Elem()
+			if rv.Kind() != reflect.Ptr {
 				break
 			}
 		}
 	}
-	if ok {
-		return
+
+	if useLookupRecognizedTypes && tryRecognized && isRecognizedRtid(rv2rtid(rv)) {
+		if rvpValid {
+			d.decode(rv2i(rvp))
+			return
+		} else if rv.CanAddr() {
+			d.decode(rv2i(rv.Addr()))
+			return
+		}
 	}
 
-	if useMapForCodecCache {
-		if d.f == nil {
-			d.f = make(map[uintptr]*decFn, initCollectionCap)
+	if fn == nil {
+		// always pass checkCodecSelfer=true, in case T or ****T is passed, where *T is a Selfer
+		fn = d.cf.get(rv.Type(), chkAll, true) // chkAll, chkAll)
+	}
+	if fn.i.addr {
+		if rvpValid {
+			fn.fd(d, &fn.i, rvp)
+		} else if rv.CanAddr() {
+			fn.fd(d, &fn.i, rv.Addr())
+		} else {
+			fn.fd(d, &fn.i, rv)
 		}
-		fn = new(decFn)
-		d.f[rtid] = fn
 	} else {
-		if d.s == nil {
-			d.s = make([]decRtidFn, 0, initCollectionCap)
-		}
-		d.s = append(d.s, decRtidFn{rtid: rtid})
-		fn = &(d.s[len(d.s)-1]).fn
+		fn.fd(d, &fn.i, rv)
 	}
-
-	// debugf("\tCreating new dec fn for type: %v\n", rt)
-	ti := d.h.getTypeInfo(rtid, rt)
-	fi := &(fn.i)
-	fi.d = d
-	fi.ti = ti
-
-	// An extension can be registered for any type, regardless of the Kind
-	// (e.g. type BitSet int64, type MyStruct { / * unexported fields * / }, type X []int, etc.
-	//
-	// We can't check if it's an extension byte here first, because the user may have
-	// registered a pointer or non-pointer type, meaning we may have to recurse first
-	// before matching a mapped type, even though the extension byte is already detected.
-	//
-	// NOTE: if decoding into a nil interface{}, we return a non-nil
-	// value except even if the container registers a length of 0.
-	if checkCodecSelfer && ti.cs {
-		fn.f = (*decFnInfo).selferUnmarshal
-	} else if rtid == rawExtTypId {
-		fn.f = (*decFnInfo).rawExt
-	} else if rtid == rawTypId {
-		fn.f = (*decFnInfo).raw
-	} else if d.d.IsBuiltinType(rtid) {
-		fn.f = (*decFnInfo).builtin
-	} else if xfFn := d.h.getExt(rtid); xfFn != nil {
-		fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
-		fn.f = (*decFnInfo).ext
-	} else if supportMarshalInterfaces && d.be && ti.bunm {
-		fn.f = (*decFnInfo).binaryUnmarshal
-	} else if supportMarshalInterfaces && !d.be && d.js && ti.junm {
-		//If JSON, we should check JSONUnmarshal before textUnmarshal
-		fn.f = (*decFnInfo).jsonUnmarshal
-	} else if supportMarshalInterfaces && !d.be && ti.tunm {
-		fn.f = (*decFnInfo).textUnmarshal
-	} else {
-		rk := rt.Kind()
-		if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) {
-			if rt.PkgPath() == "" {
-				if idx := fastpathAV.index(rtid); idx != -1 {
-					fn.f = fastpathAV[idx].decfn
-				}
-			} else {
-				// use mapping for underlying type if there
-				ok = false
-				var rtu reflect.Type
-				if rk == reflect.Map {
-					rtu = reflect.MapOf(rt.Key(), rt.Elem())
-				} else {
-					rtu = reflect.SliceOf(rt.Elem())
-				}
-				rtuid := reflect.ValueOf(rtu).Pointer()
-				if idx := fastpathAV.index(rtuid); idx != -1 {
-					xfnf := fastpathAV[idx].decfn
-					xrt := fastpathAV[idx].rt
-					fn.f = func(xf *decFnInfo, xrv reflect.Value) {
-						// xfnf(xf, xrv.Convert(xrt))
-						xfnf(xf, xrv.Addr().Convert(reflect.PtrTo(xrt)).Elem())
-					}
-				}
-			}
-		}
-		if fn.f == nil {
-			switch rk {
-			case reflect.String:
-				fn.f = (*decFnInfo).kString
-			case reflect.Bool:
-				fn.f = (*decFnInfo).kBool
-			case reflect.Int:
-				fn.f = (*decFnInfo).kInt
-			case reflect.Int64:
-				fn.f = (*decFnInfo).kInt64
-			case reflect.Int32:
-				fn.f = (*decFnInfo).kInt32
-			case reflect.Int8:
-				fn.f = (*decFnInfo).kInt8
-			case reflect.Int16:
-				fn.f = (*decFnInfo).kInt16
-			case reflect.Float32:
-				fn.f = (*decFnInfo).kFloat32
-			case reflect.Float64:
-				fn.f = (*decFnInfo).kFloat64
-			case reflect.Uint8:
-				fn.f = (*decFnInfo).kUint8
-			case reflect.Uint64:
-				fn.f = (*decFnInfo).kUint64
-			case reflect.Uint:
-				fn.f = (*decFnInfo).kUint
-			case reflect.Uint32:
-				fn.f = (*decFnInfo).kUint32
-			case reflect.Uint16:
-				fn.f = (*decFnInfo).kUint16
-				// case reflect.Ptr:
-				// 	fn.f = (*decFnInfo).kPtr
-			case reflect.Uintptr:
-				fn.f = (*decFnInfo).kUintptr
-			case reflect.Interface:
-				fn.f = (*decFnInfo).kInterface
-			case reflect.Struct:
-				fn.f = (*decFnInfo).kStruct
-			case reflect.Chan:
-				fi.seq = seqTypeChan
-				fn.f = (*decFnInfo).kSlice
-			case reflect.Slice:
-				fi.seq = seqTypeSlice
-				fn.f = (*decFnInfo).kSlice
-			case reflect.Array:
-				fi.seq = seqTypeArray
-				fn.f = (*decFnInfo).kArray
-			case reflect.Map:
-				fn.f = (*decFnInfo).kMap
-			default:
-				fn.f = (*decFnInfo).kErr
-			}
-		}
-	}
-
-	return
+	// return rv
 }
 
 func (d *Decoder) structFieldNotFound(index int, rvkencname string) {
@@ -1839,15 +2253,33 @@ func (d *Decoder) arrayCannotExpand(sliceLen, streamLen int) {
 	}
 }
 
-func (d *Decoder) chkPtrValue(rv reflect.Value) {
-	// We can only decode into a non-nil pointer
-	if rv.Kind() == reflect.Ptr && !rv.IsNil() {
-		return
+func isDecodeable(rv reflect.Value) (rv2 reflect.Value, canDecode bool) {
+	switch rv.Kind() {
+	case reflect.Array:
+		return rv, true
+	case reflect.Ptr:
+		if !rv.IsNil() {
+			return rv.Elem(), true
+		}
+	case reflect.Slice, reflect.Chan, reflect.Map:
+		if !rv.IsNil() {
+			return rv, true
+		}
 	}
-	d.errNotValidPtrValue(rv)
+	return
 }
 
-func (d *Decoder) errNotValidPtrValue(rv reflect.Value) {
+func (d *Decoder) ensureDecodeable(rv reflect.Value) (rv2 reflect.Value) {
+	// decode can take any reflect.Value that is a inherently addressable i.e.
+	//   - array
+	//   - non-nil chan    (we will SEND to it)
+	//   - non-nil slice   (we will set its elements)
+	//   - non-nil map     (we will put into it)
+	//   - non-nil pointer (we can "update" it)
+	rv2, canDecode := isDecodeable(rv)
+	if canDecode {
+		return
+	}
 	if !rv.IsValid() {
 		d.error(cannotDecodeIntoNilErr)
 		return
@@ -1856,10 +2288,32 @@ func (d *Decoder) errNotValidPtrValue(rv reflect.Value) {
 		d.errorf("cannot decode into a value without an interface: %v", rv)
 		return
 	}
-	rvi := rv.Interface()
-	d.errorf("cannot decode into non-pointer or nil pointer. Got: %v, %T, %v", rv.Kind(), rvi, rvi)
+	rvi := rv2i(rv)
+	d.errorf("cannot decode into value of kind: %v, type: %T, %v", rv.Kind(), rvi, rvi)
+	return
 }
 
+// func (d *Decoder) chkPtrValue(rv reflect.Value) {
+// 	// We can only decode into a non-nil pointer
+// 	if rv.Kind() == reflect.Ptr && !rv.IsNil() {
+// 		return
+// 	}
+// 	d.errNotValidPtrValue(rv)
+// }
+
+// func (d *Decoder) errNotValidPtrValue(rv reflect.Value) {
+// 	if !rv.IsValid() {
+// 		d.error(cannotDecodeIntoNilErr)
+// 		return
+// 	}
+// 	if !rv.CanInterface() {
+// 		d.errorf("cannot decode into a value without an interface: %v", rv)
+// 		return
+// 	}
+// 	rvi := rv2i(rv)
+// 	d.errorf("cannot decode into non-pointer or nil pointer. Got: %v, %T, %v", rv.Kind(), rvi, rvi)
+// }
+
 func (d *Decoder) error(err error) {
 	panic(err)
 }
@@ -1872,33 +2326,32 @@ func (d *Decoder) errorf(format string, params ...interface{}) {
 	panic(err)
 }
 
+// Possibly get an interned version of a string
+//
+// This should mostly be used for map keys, where the key type is string.
+// This is because keys of a map/struct are typically reused across many objects.
 func (d *Decoder) string(v []byte) (s string) {
-	if d.is != nil {
-		s, ok := d.is[string(v)] // no allocation here.
-		if !ok {
-			s = string(v)
-			d.is[s] = s
-		}
-		return s
+	if d.is == nil {
+		return string(v) // don't return stringView, as we need a real string here.
 	}
-	return string(v) // don't return stringView, as we need a real string here.
-}
-
-func (d *Decoder) intern(s string) {
-	if d.is != nil {
+	s, ok := d.is[string(v)] // no allocation here, per go implementation
+	if !ok {
+		s = string(v) // new allocation here
 		d.is[s] = s
 	}
+	return s
 }
 
 // nextValueBytes returns the next value in the stream as a set of bytes.
-func (d *Decoder) nextValueBytes() []byte {
+func (d *Decoder) nextValueBytes() (bs []byte) {
 	d.d.uncacheRead()
 	d.r.track()
 	d.swallow()
-	return d.r.stopTrack()
+	bs = d.r.stopTrack()
+	return
 }
 
-func (d *Decoder) raw() []byte {
+func (d *Decoder) rawBytes() []byte {
 	// ensure that this is not a view into the bytes
 	// i.e. make new copy always.
 	bs := d.nextValueBytes()
@@ -1934,45 +2387,49 @@ func (d *Decoder) decSliceHelperStart() (x decSliceHelper, clen int) {
 }
 
 func (x decSliceHelper) End() {
-	cr := x.d.cr
-	if cr == nil {
-		return
-	}
 	if x.array {
-		cr.sendContainerState(containerArrayEnd)
+		x.d.d.ReadArrayEnd()
 	} else {
-		cr.sendContainerState(containerMapEnd)
+		x.d.d.ReadMapEnd()
 	}
 }
 
 func (x decSliceHelper) ElemContainerState(index int) {
-	cr := x.d.cr
-	if cr == nil {
-		return
-	}
 	if x.array {
-		cr.sendContainerState(containerArrayElem)
+		x.d.d.ReadArrayElem()
 	} else {
 		if index%2 == 0 {
-			cr.sendContainerState(containerMapKey)
+			x.d.d.ReadMapElemKey()
 		} else {
-			cr.sendContainerState(containerMapValue)
+			x.d.d.ReadMapElemValue()
 		}
 	}
 }
 
-func decByteSlice(r decReader, clen int, bs []byte) (bsOut []byte) {
+func decByteSlice(r decReader, clen, maxInitLen int, bs []byte) (bsOut []byte) {
 	if clen == 0 {
 		return zeroByteSlice
 	}
 	if len(bs) == clen {
 		bsOut = bs
+		r.readb(bsOut)
 	} else if cap(bs) >= clen {
 		bsOut = bs[:clen]
+		r.readb(bsOut)
 	} else {
-		bsOut = make([]byte, clen)
+		// bsOut = make([]byte, clen)
+		len2 := decInferLen(clen, maxInitLen, 1)
+		bsOut = make([]byte, len2)
+		r.readb(bsOut)
+		for len2 < clen {
+			len3 := decInferLen(clen-len2, maxInitLen, 1)
+			bs3 := bsOut
+			bsOut = make([]byte, len2+len3)
+			copy(bsOut, bs3)
+			r.readb(bsOut[len2:])
+			len2 += len3
+		}
 	}
-	r.readb(bsOut)
 	return
 }
 
@@ -1996,7 +2453,7 @@ func detachZeroCopyBytes(isBytesReader bool, dest []byte, in []byte) (out []byte
 //    - maxlen: max length to be returned.
 //      if <= 0, it is unset, and we infer it based on the unit size
 //    - unit: number of bytes for each element of the collection
-func decInferLen(clen, maxlen, unit int) (rvlen int, truncated bool) {
+func decInferLen(clen, maxlen, unit int) (rvlen int) {
 	// handle when maxlen is not set i.e. <= 0
 	if clen <= 0 {
 		return
@@ -2015,39 +2472,49 @@ func decInferLen(clen, maxlen, unit int) (rvlen int, truncated bool) {
 	}
 	if clen > maxlen {
 		rvlen = maxlen
-		truncated = true
 	} else {
 		rvlen = clen
 	}
 	return
-	// if clen <= 0 {
-	// 	rvlen = 0
-	// } else if maxlen > 0 && clen > maxlen {
-	// 	rvlen = maxlen
-	// 	truncated = true
-	// } else {
-	// 	rvlen = clen
-	// }
-	// return
 }
 
-// // implement overall decReader wrapping both, for possible use inline:
-// type decReaderT struct {
-// 	bytes bool
-// 	rb    *bytesDecReader
-// 	ri    *ioDecReader
-// }
-//
-// // implement *Decoder as a decReader.
-// // Using decReaderT (defined just above) caused performance degradation
-// // possibly because of constant copying the value,
-// // and some value->interface conversion causing allocation.
-// func (d *Decoder) unreadn1() {
-// 	if d.bytes {
-// 		d.rb.unreadn1()
-// 	} else {
-// 		d.ri.unreadn1()
-// 	}
-// }
-// ... for other methods of decReader.
-// Testing showed that performance improvement was negligible.
+func decExpandSliceRV(s reflect.Value, st reflect.Type, stElemSize, num, slen, scap int) (
+	s2 reflect.Value, scap2 int, changed bool) {
+	l1 := slen + num // new slice length
+	if l1 < slen {
+		panic("expandSlice: slice overflow")
+	}
+	if l1 <= scap {
+		if s.CanSet() {
+			s.SetLen(l1)
+		} else {
+			s2 = s.Slice(0, l1)
+			scap2 = scap
+			changed = true
+		}
+		return
+	}
+	scap2 = growCap(scap, stElemSize, num)
+	s2 = reflect.MakeSlice(st, l1, scap2)
+	changed = true
+	reflect.Copy(s2, s)
+	return
+}
+
+func decReadFull(r io.Reader, bs []byte) (n int, err error) {
+	var nn int
+	for n < len(bs) && err == nil {
+		nn, err = r.Read(bs[n:])
+		if nn > 0 {
+			if err == io.EOF {
+				// leave EOF for next time
+				err = nil
+			}
+			n += nn
+		}
+	}
+
+	// do not do this - it serves no purpose
+	// if n != len(bs) && err == io.EOF { err = io.ErrUnexpectedEOF }
+	return
+}
diff --git a/vendor/github.com/ugorji/go/codec/encode.go b/vendor/github.com/ugorji/go/codec/encode.go
index c2cef812ec7..dd15a2f4ff2 100644
--- a/vendor/github.com/ugorji/go/codec/encode.go
+++ b/vendor/github.com/ugorji/go/codec/encode.go
@@ -4,6 +4,7 @@
 package codec
 
 import (
+	"bufio"
 	"encoding"
 	"fmt"
 	"io"
@@ -12,9 +13,7 @@ import (
 	"sync"
 )
 
-const (
-	defEncByteBufSize = 1 << 6 // 4:16, 6:64, 8:256, 10:1024
-)
+const defEncByteBufSize = 1 << 6 // 4:16, 6:64, 8:256, 10:1024
 
 // AsSymbolFlag defines what should be encoded as symbols.
 type AsSymbolFlag uint8
@@ -44,12 +43,14 @@ type encWriter interface {
 	writestr(string)
 	writen1(byte)
 	writen2(byte, byte)
+	writen4(byte, byte, byte, byte)
+	writen5(byte, byte, byte, byte, byte)
 	atEndOfEncode()
 }
 
 // encDriver abstracts the actual codec (binc vs msgpack, etc)
 type encDriver interface {
-	IsBuiltinType(rt uintptr) bool
+	// IsBuiltinType(rt uintptr) bool
 	EncodeBuiltin(rt uintptr, v interface{})
 	EncodeNil()
 	EncodeInt(i int64)
@@ -60,8 +61,13 @@ type encDriver interface {
 	// encodeExtPreamble(xtag byte, length int)
 	EncodeRawExt(re *RawExt, e *Encoder)
 	EncodeExt(v interface{}, xtag uint64, ext Ext, e *Encoder)
-	EncodeArrayStart(length int)
-	EncodeMapStart(length int)
+	WriteArrayStart(length int)
+	WriteArrayElem()
+	WriteArrayEnd()
+	WriteMapStart(length int)
+	WriteMapElemKey()
+	WriteMapElemValue()
+	WriteMapEnd()
 	EncodeString(c charEncoding, v string)
 	EncodeSymbol(v string)
 	EncodeStringBytes(c charEncoding, v []byte)
@@ -70,25 +76,40 @@ type encDriver interface {
 	//encStringRunes(c charEncoding, v []rune)
 
 	reset()
+	atEndOfEncode()
+}
+
+type ioEncStringWriter interface {
+	WriteString(s string) (n int, err error)
+}
+
+type ioEncFlusher interface {
+	Flush() error
 }
 
 type encDriverAsis interface {
 	EncodeAsis(v []byte)
 }
 
-type encNoSeparator struct{}
+// type encNoSeparator struct{}
+// func (_ encNoSeparator) EncodeEnd() {}
 
-func (_ encNoSeparator) EncodeEnd() {}
+type encDriverNoopContainerWriter struct{}
 
-type ioEncWriterWriter interface {
-	WriteByte(c byte) error
-	WriteString(s string) (n int, err error)
-	Write(p []byte) (n int, err error)
-}
+func (_ encDriverNoopContainerWriter) WriteArrayStart(length int) {}
+func (_ encDriverNoopContainerWriter) WriteArrayElem()            {}
+func (_ encDriverNoopContainerWriter) WriteArrayEnd()             {}
+func (_ encDriverNoopContainerWriter) WriteMapStart(length int)   {}
+func (_ encDriverNoopContainerWriter) WriteMapElemKey()           {}
+func (_ encDriverNoopContainerWriter) WriteMapElemValue()         {}
+func (_ encDriverNoopContainerWriter) WriteMapEnd()               {}
+func (_ encDriverNoopContainerWriter) atEndOfEncode()             {}
 
-type ioEncStringWriter interface {
-	WriteString(s string) (n int, err error)
-}
+// type ioEncWriterWriter interface {
+// 	WriteByte(c byte) error
+// 	WriteString(s string) (n int, err error)
+// 	Write(p []byte) (n int, err error)
+// }
 
 type EncodeOptions struct {
 	// Encode a struct as an array, and not as a map
@@ -146,83 +167,118 @@ type EncodeOptions struct {
 	//   AsSymbolMapStringKeys
 	//   AsSymbolMapStringKeysFlag | AsSymbolStructFieldNameFlag
 	AsSymbols AsSymbolFlag
+
+	// WriterBufferSize is the size of the buffer used when writing.
+	//
+	// if > 0, we use a smart buffer internally for performance purposes.
+	WriterBufferSize int
 }
 
 // ---------------------------------------------
 
-type simpleIoEncWriterWriter struct {
-	w  io.Writer
-	bw io.ByteWriter
-	sw ioEncStringWriter
-	bs [1]byte
+type simpleIoEncWriter struct {
+	io.Writer
 }
 
-func (o *simpleIoEncWriterWriter) WriteByte(c byte) (err error) {
-	if o.bw != nil {
-		return o.bw.WriteByte(c)
-	}
-	// _, err = o.w.Write([]byte{c})
-	o.bs[0] = c
-	_, err = o.w.Write(o.bs[:])
-	return
-}
+// type bufIoEncWriter struct {
+// 	w   io.Writer
+// 	buf []byte
+// 	err error
+// }
 
-func (o *simpleIoEncWriterWriter) WriteString(s string) (n int, err error) {
-	if o.sw != nil {
-		return o.sw.WriteString(s)
-	}
-	// return o.w.Write([]byte(s))
-	return o.w.Write(bytesView(s))
-}
-
-func (o *simpleIoEncWriterWriter) Write(p []byte) (n int, err error) {
-	return o.w.Write(p)
-}
-
-// ----------------------------------------
+// func (x *bufIoEncWriter) Write(b []byte) (n int, err error) {
+// 	if x.err != nil {
+// 		return 0, x.err
+// 	}
+// 	if cap(x.buf)-len(x.buf) >= len(b) {
+// 		x.buf = append(x.buf, b)
+// 		return len(b), nil
+// 	}
+// 	n, err = x.w.Write(x.buf)
+// 	if err != nil {
+// 		x.err = err
+// 		return 0, x.err
+// 	}
+// 	n, err = x.w.Write(b)
+// 	x.err = err
+// 	return
+// }
 
 // ioEncWriter implements encWriter and can write to an io.Writer implementation
 type ioEncWriter struct {
-	w ioEncWriterWriter
-	s simpleIoEncWriterWriter
-	// x [8]byte // temp byte array re-used internally for efficiency
+	w  io.Writer
+	ww io.Writer
+	bw io.ByteWriter
+	sw ioEncStringWriter
+	fw ioEncFlusher
+	b  [8]byte
+}
+
+func (z *ioEncWriter) WriteByte(b byte) (err error) {
+	// x.bs[0] = b
+	// _, err = x.ww.Write(x.bs[:])
+	z.b[0] = b
+	_, err = z.w.Write(z.b[:1])
+	return
+}
+
+func (z *ioEncWriter) WriteString(s string) (n int, err error) {
+	return z.w.Write(bytesView(s))
 }
 
 func (z *ioEncWriter) writeb(bs []byte) {
-	if len(bs) == 0 {
-		return
-	}
-	n, err := z.w.Write(bs)
-	if err != nil {
+	// if len(bs) == 0 {
+	// 	return
+	// }
+	if _, err := z.ww.Write(bs); err != nil {
 		panic(err)
 	}
-	if n != len(bs) {
-		panic(fmt.Errorf("incorrect num bytes written. Expecting: %v, Wrote: %v", len(bs), n))
-	}
 }
 
 func (z *ioEncWriter) writestr(s string) {
-	n, err := z.w.WriteString(s)
-	if err != nil {
+	// if len(s) == 0 {
+	// 	return
+	// }
+	if _, err := z.sw.WriteString(s); err != nil {
 		panic(err)
 	}
-	if n != len(s) {
-		panic(fmt.Errorf("incorrect num bytes written. Expecting: %v, Wrote: %v", len(s), n))
-	}
 }
 
 func (z *ioEncWriter) writen1(b byte) {
-	if err := z.w.WriteByte(b); err != nil {
+	if err := z.bw.WriteByte(b); err != nil {
 		panic(err)
 	}
 }
 
-func (z *ioEncWriter) writen2(b1 byte, b2 byte) {
-	z.writen1(b1)
-	z.writen1(b2)
+func (z *ioEncWriter) writen2(b1, b2 byte) {
+	var err error
+	if err = z.bw.WriteByte(b1); err == nil {
+		if err = z.bw.WriteByte(b2); err == nil {
+			return
+		}
+	}
+	panic(err)
 }
 
-func (z *ioEncWriter) atEndOfEncode() {}
+func (z *ioEncWriter) writen4(b1, b2, b3, b4 byte) {
+	z.b[0], z.b[1], z.b[2], z.b[3] = b1, b2, b3, b4
+	if _, err := z.ww.Write(z.b[:4]); err != nil {
+		panic(err)
+	}
+}
+
+func (z *ioEncWriter) writen5(b1, b2, b3, b4, b5 byte) {
+	z.b[0], z.b[1], z.b[2], z.b[3], z.b[4] = b1, b2, b3, b4, b5
+	if _, err := z.ww.Write(z.b[:5]); err != nil {
+		panic(err)
+	}
+}
+
+func (z *ioEncWriter) atEndOfEncode() {
+	if z.fw != nil {
+		z.fw.Flush()
+	}
+}
 
 // ----------------------------------------
 
@@ -235,9 +291,6 @@ type bytesEncWriter struct {
 }
 
 func (z *bytesEncWriter) writeb(s []byte) {
-	if len(s) == 0 {
-		return
-	}
 	oc, a := z.growNoAlloc(len(s))
 	if a {
 		z.growAlloc(len(s), oc)
@@ -246,9 +299,6 @@ func (z *bytesEncWriter) writeb(s []byte) {
 }
 
 func (z *bytesEncWriter) writestr(s string) {
-	if len(s) == 0 {
-		return
-	}
 	oc, a := z.growNoAlloc(len(s))
 	if a {
 		z.growAlloc(len(s), oc)
@@ -264,7 +314,7 @@ func (z *bytesEncWriter) writen1(b1 byte) {
 	z.b[oc] = b1
 }
 
-func (z *bytesEncWriter) writen2(b1 byte, b2 byte) {
+func (z *bytesEncWriter) writen2(b1, b2 byte) {
 	oc, a := z.growNoAlloc(2)
 	if a {
 		z.growAlloc(2, oc)
@@ -273,6 +323,29 @@ func (z *bytesEncWriter) writen2(b1 byte, b2 byte) {
 	z.b[oc] = b1
 }
 
+func (z *bytesEncWriter) writen4(b1, b2, b3, b4 byte) {
+	oc, a := z.growNoAlloc(4)
+	if a {
+		z.growAlloc(4, oc)
+	}
+	z.b[oc+3] = b4
+	z.b[oc+2] = b3
+	z.b[oc+1] = b2
+	z.b[oc] = b1
+}
+
+func (z *bytesEncWriter) writen5(b1, b2, b3, b4, b5 byte) {
+	oc, a := z.growNoAlloc(5)
+	if a {
+		z.growAlloc(5, oc)
+	}
+	z.b[oc+4] = b5
+	z.b[oc+3] = b4
+	z.b[oc+2] = b3
+	z.b[oc+1] = b2
+	z.b[oc] = b1
+}
+
 func (z *bytesEncWriter) atEndOfEncode() {
 	*(z.out) = z.b[:z.c]
 }
@@ -304,158 +377,147 @@ func (z *bytesEncWriter) growAlloc(n int, oldcursor int) {
 
 // ---------------------------------------------
 
-type encFnInfo struct {
-	e     *Encoder
-	ti    *typeInfo
-	xfFn  Ext
-	xfTag uint64
-	seq   seqType
+func (e *Encoder) builtin(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeBuiltin(f.ti.rtid, rv2i(rv))
 }
 
-func (f *encFnInfo) builtin(rv reflect.Value) {
-	f.e.e.EncodeBuiltin(f.ti.rtid, rv.Interface())
+func (e *Encoder) raw(f *codecFnInfo, rv reflect.Value) {
+	e.rawBytes(rv2i(rv).(Raw))
 }
 
-func (f *encFnInfo) raw(rv reflect.Value) {
-	f.e.raw(rv.Interface().(Raw))
-}
-
-func (f *encFnInfo) rawExt(rv reflect.Value) {
-	// rev := rv.Interface().(RawExt)
-	// f.e.e.EncodeRawExt(&rev, f.e)
+func (e *Encoder) rawExt(f *codecFnInfo, rv reflect.Value) {
+	// rev := rv2i(rv).(RawExt)
+	// e.e.EncodeRawExt(&rev, e)
 	var re *RawExt
 	if rv.CanAddr() {
-		re = rv.Addr().Interface().(*RawExt)
+		re = rv2i(rv.Addr()).(*RawExt)
 	} else {
-		rev := rv.Interface().(RawExt)
+		rev := rv2i(rv).(RawExt)
 		re = &rev
 	}
-	f.e.e.EncodeRawExt(re, f.e)
+	e.e.EncodeRawExt(re, e)
 }
 
-func (f *encFnInfo) ext(rv reflect.Value) {
+func (e *Encoder) ext(f *codecFnInfo, rv reflect.Value) {
 	// if this is a struct|array and it was addressable, then pass the address directly (not the value)
 	if k := rv.Kind(); (k == reflect.Struct || k == reflect.Array) && rv.CanAddr() {
 		rv = rv.Addr()
 	}
-	f.e.e.EncodeExt(rv.Interface(), f.xfTag, f.xfFn, f.e)
+	e.e.EncodeExt(rv2i(rv), f.xfTag, f.xfFn, e)
 }
 
-func (f *encFnInfo) getValueForMarshalInterface(rv reflect.Value, indir int8) (v interface{}, proceed bool) {
+func (e *Encoder) getValueForMarshalInterface(rv reflect.Value, indir int8) (v interface{}, proceed bool) {
 	if indir == 0 {
-		v = rv.Interface()
+		v = rv2i(rv)
 	} else if indir == -1 {
 		// If a non-pointer was passed to Encode(), then that value is not addressable.
 		// Take addr if addressable, else copy value to an addressable value.
 		if rv.CanAddr() {
-			v = rv.Addr().Interface()
+			v = rv2i(rv.Addr())
 		} else {
 			rv2 := reflect.New(rv.Type())
 			rv2.Elem().Set(rv)
-			v = rv2.Interface()
-			// fmt.Printf("rv.Type: %v, rv2.Type: %v, v: %v\n", rv.Type(), rv2.Type(), v)
+			v = rv2i(rv2)
 		}
 	} else {
 		for j := int8(0); j < indir; j++ {
 			if rv.IsNil() {
-				f.e.e.EncodeNil()
+				e.e.EncodeNil()
 				return
 			}
 			rv = rv.Elem()
 		}
-		v = rv.Interface()
+		v = rv2i(rv)
 	}
 	return v, true
 }
 
-func (f *encFnInfo) selferMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.csIndir); proceed {
-		v.(Selfer).CodecEncodeSelf(f.e)
+func (e *Encoder) selferMarshal(f *codecFnInfo, rv reflect.Value) {
+	if v, proceed := e.getValueForMarshalInterface(rv, f.ti.csIndir); proceed {
+		v.(Selfer).CodecEncodeSelf(e)
 	}
 }
 
-func (f *encFnInfo) binaryMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.bmIndir); proceed {
+func (e *Encoder) binaryMarshal(f *codecFnInfo, rv reflect.Value) {
+	if v, proceed := e.getValueForMarshalInterface(rv, f.ti.bmIndir); proceed {
 		bs, fnerr := v.(encoding.BinaryMarshaler).MarshalBinary()
-		f.e.marshal(bs, fnerr, false, c_RAW)
+		e.marshal(bs, fnerr, false, c_RAW)
 	}
 }
 
-func (f *encFnInfo) textMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.tmIndir); proceed {
-		// debugf(">>>> encoding.TextMarshaler: %T", rv.Interface())
+func (e *Encoder) textMarshal(f *codecFnInfo, rv reflect.Value) {
+	if v, proceed := e.getValueForMarshalInterface(rv, f.ti.tmIndir); proceed {
 		bs, fnerr := v.(encoding.TextMarshaler).MarshalText()
-		f.e.marshal(bs, fnerr, false, c_UTF8)
+		e.marshal(bs, fnerr, false, c_UTF8)
 	}
 }
 
-func (f *encFnInfo) jsonMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.jmIndir); proceed {
+func (e *Encoder) jsonMarshal(f *codecFnInfo, rv reflect.Value) {
+	if v, proceed := e.getValueForMarshalInterface(rv, f.ti.jmIndir); proceed {
 		bs, fnerr := v.(jsonMarshaler).MarshalJSON()
-		f.e.marshal(bs, fnerr, true, c_UTF8)
+		e.marshal(bs, fnerr, true, c_UTF8)
 	}
 }
 
-func (f *encFnInfo) kBool(rv reflect.Value) {
-	f.e.e.EncodeBool(rv.Bool())
+func (e *Encoder) kBool(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeBool(rv.Bool())
 }
 
-func (f *encFnInfo) kString(rv reflect.Value) {
-	f.e.e.EncodeString(c_UTF8, rv.String())
+func (e *Encoder) kString(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeString(c_UTF8, rv.String())
 }
 
-func (f *encFnInfo) kFloat64(rv reflect.Value) {
-	f.e.e.EncodeFloat64(rv.Float())
+func (e *Encoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeFloat64(rv.Float())
 }
 
-func (f *encFnInfo) kFloat32(rv reflect.Value) {
-	f.e.e.EncodeFloat32(float32(rv.Float()))
+func (e *Encoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeFloat32(float32(rv.Float()))
 }
 
-func (f *encFnInfo) kInt(rv reflect.Value) {
-	f.e.e.EncodeInt(rv.Int())
+func (e *Encoder) kInt(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
 }
 
-func (f *encFnInfo) kUint(rv reflect.Value) {
-	f.e.e.EncodeUint(rv.Uint())
+func (e *Encoder) kUint(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
 }
 
-func (f *encFnInfo) kInvalid(rv reflect.Value) {
-	f.e.e.EncodeNil()
+func (e *Encoder) kInvalid(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeNil()
 }
 
-func (f *encFnInfo) kErr(rv reflect.Value) {
-	f.e.errorf("unsupported kind %s, for %#v", rv.Kind(), rv)
+func (e *Encoder) kErr(f *codecFnInfo, rv reflect.Value) {
+	e.errorf("unsupported kind %s, for %#v", rv.Kind(), rv)
 }
 
-func (f *encFnInfo) kSlice(rv reflect.Value) {
+func (e *Encoder) kSlice(f *codecFnInfo, rv reflect.Value) {
 	ti := f.ti
+	ee := e.e
 	// array may be non-addressable, so we have to manage with care
 	//   (don't call rv.Bytes, rv.Slice, etc).
 	// E.g. type struct S{B [2]byte};
 	//   Encode(S{}) will bomb on "panic: slice of unaddressable array".
-	e := f.e
 	if f.seq != seqTypeArray {
 		if rv.IsNil() {
-			e.e.EncodeNil()
+			ee.EncodeNil()
 			return
 		}
 		// If in this method, then there was no extension function defined.
 		// So it's okay to treat as []byte.
 		if ti.rtid == uint8SliceTypId {
-			e.e.EncodeStringBytes(c_RAW, rv.Bytes())
+			ee.EncodeStringBytes(c_RAW, rv.Bytes())
 			return
 		}
 	}
-	cr := e.cr
+	elemsep := e.hh.hasElemSeparators()
 	rtelem := ti.rt.Elem()
 	l := rv.Len()
 	if ti.rtid == uint8SliceTypId || rtelem.Kind() == reflect.Uint8 {
 		switch f.seq {
 		case seqTypeArray:
-			// if l == 0 { e.e.encodeStringBytes(c_RAW, nil) } else
 			if rv.CanAddr() {
-				e.e.EncodeStringBytes(c_RAW, rv.Slice(0, l).Bytes())
+				ee.EncodeStringBytes(c_RAW, rv.Slice(0, l).Bytes())
 			} else {
 				var bs []byte
 				if l <= cap(e.b) {
@@ -464,27 +526,24 @@ func (f *encFnInfo) kSlice(rv reflect.Value) {
 					bs = make([]byte, l)
 				}
 				reflect.Copy(reflect.ValueOf(bs), rv)
-				// TODO: Test that reflect.Copy works instead of manual one-by-one
-				// for i := 0; i < l; i++ {
-				// 	bs[i] = byte(rv.Index(i).Uint())
-				// }
-				e.e.EncodeStringBytes(c_RAW, bs)
+				ee.EncodeStringBytes(c_RAW, bs)
 			}
+			return
 		case seqTypeSlice:
-			e.e.EncodeStringBytes(c_RAW, rv.Bytes())
-		case seqTypeChan:
-			bs := e.b[:0]
-			// do not use range, so that the number of elements encoded
-			// does not change, and encoding does not hang waiting on someone to close chan.
-			// for b := range rv.Interface().(<-chan byte) {
-			// 	bs = append(bs, b)
-			// }
-			ch := rv.Interface().(<-chan byte)
-			for i := 0; i < l; i++ {
-				bs = append(bs, <-ch)
-			}
-			e.e.EncodeStringBytes(c_RAW, bs)
+			ee.EncodeStringBytes(c_RAW, rv.Bytes())
+			return
 		}
+	}
+	if ti.rtid == uint8SliceTypId && f.seq == seqTypeChan {
+		bs := e.b[:0]
+		// do not use range, so that the number of elements encoded
+		// does not change, and encoding does not hang waiting on someone to close chan.
+		// for b := range rv2i(rv).(<-chan byte) { bs = append(bs, b) }
+		ch := rv2i(rv).(<-chan byte)
+		for i := 0; i < l; i++ {
+			bs = append(bs, <-ch)
+		}
+		ee.EncodeStringBytes(c_RAW, bs)
 		return
 	}
 
@@ -493,78 +552,171 @@ func (f *encFnInfo) kSlice(rv reflect.Value) {
 			e.errorf("mapBySlice requires even slice length, but got %v", l)
 			return
 		}
-		e.e.EncodeMapStart(l / 2)
+		ee.WriteMapStart(l / 2)
 	} else {
-		e.e.EncodeArrayStart(l)
+		ee.WriteArrayStart(l)
 	}
 
 	if l > 0 {
-		for rtelem.Kind() == reflect.Ptr {
-			rtelem = rtelem.Elem()
-		}
-		// if kind is reflect.Interface, do not pre-determine the
-		// encoding type, because preEncodeValue may break it down to
-		// a concrete type and kInterface will bomb.
-		var fn *encFn
-		if rtelem.Kind() != reflect.Interface {
-			rtelemid := reflect.ValueOf(rtelem).Pointer()
-			fn = e.getEncFn(rtelemid, rtelem, true, true)
+		var fn *codecFn
+		var recognizedVtyp = useLookupRecognizedTypes && isRecognizedRtidOrPtr(rt2id(rtelem))
+		if !recognizedVtyp {
+			for rtelem.Kind() == reflect.Ptr {
+				rtelem = rtelem.Elem()
+			}
+			// if kind is reflect.Interface, do not pre-determine the
+			// encoding type, because preEncodeValue may break it down to
+			// a concrete type and kInterface will bomb.
+			if rtelem.Kind() != reflect.Interface {
+				fn = e.cf.get(rtelem, true, true)
+			}
 		}
 		// TODO: Consider perf implication of encoding odd index values as symbols if type is string
 		for j := 0; j < l; j++ {
-			if cr != nil {
+			if elemsep {
 				if ti.mbs {
 					if j%2 == 0 {
-						cr.sendContainerState(containerMapKey)
+						ee.WriteMapElemKey()
 					} else {
-						cr.sendContainerState(containerMapValue)
+						ee.WriteMapElemValue()
 					}
 				} else {
-					cr.sendContainerState(containerArrayElem)
+					ee.WriteArrayElem()
 				}
 			}
 			if f.seq == seqTypeChan {
 				if rv2, ok2 := rv.Recv(); ok2 {
-					e.encodeValue(rv2, fn)
+					if useLookupRecognizedTypes && recognizedVtyp {
+						e.encode(rv2i(rv2))
+					} else {
+						e.encodeValue(rv2, fn, true)
+					}
 				} else {
-					e.encode(nil) // WE HAVE TO DO SOMETHING, so nil if nothing received.
+					ee.EncodeNil() // WE HAVE TO DO SOMETHING, so nil if nothing received.
 				}
 			} else {
-				e.encodeValue(rv.Index(j), fn)
+				if useLookupRecognizedTypes && recognizedVtyp {
+					e.encode(rv2i(rv.Index(j)))
+				} else {
+					e.encodeValue(rv.Index(j), fn, true)
+				}
 			}
 		}
 	}
 
-	if cr != nil {
-		if ti.mbs {
-			cr.sendContainerState(containerMapEnd)
-		} else {
-			cr.sendContainerState(containerArrayEnd)
-		}
+	if ti.mbs {
+		ee.WriteMapEnd()
+	} else {
+		ee.WriteArrayEnd()
 	}
 }
 
-func (f *encFnInfo) kStruct(rv reflect.Value) {
+func (e *Encoder) kStructNoOmitempty(f *codecFnInfo, rv reflect.Value) {
 	fti := f.ti
-	e := f.e
-	cr := e.cr
+	elemsep := e.hh.hasElemSeparators()
 	tisfi := fti.sfip
 	toMap := !(fti.toArray || e.h.StructToArray)
-	newlen := len(fti.sfi)
+	if toMap {
+		tisfi = fti.sfi
+	}
+	ee := e.e
 
-	// Use sync.Pool to reduce allocating slices unnecessarily.
-	// The cost of sync.Pool is less than the cost of new allocation.
-	pool, poolv, fkvs := encStructPoolGet(newlen)
+	sfn := structFieldNode{v: rv, update: false}
+	if toMap {
+		ee.WriteMapStart(len(tisfi))
+		// asSymbols := e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0
+		asSymbols := e.h.AsSymbols == AsSymbolDefault || e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0
+		if !elemsep {
+			for _, si := range tisfi {
+				if asSymbols {
+					ee.EncodeSymbol(si.encName)
+				} else {
+					ee.EncodeString(c_UTF8, si.encName)
+				}
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		} else {
+			for _, si := range tisfi {
+				ee.WriteMapElemKey()
+				if asSymbols {
+					ee.EncodeSymbol(si.encName)
+				} else {
+					ee.EncodeString(c_UTF8, si.encName)
+				}
+				ee.WriteMapElemValue()
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		}
+		ee.WriteMapEnd()
+	} else {
+		ee.WriteArrayStart(len(tisfi))
+		if !elemsep {
+			for _, si := range tisfi {
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		} else {
+			for _, si := range tisfi {
+				ee.WriteArrayElem()
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		}
+		ee.WriteArrayEnd()
+	}
+}
 
+func (e *Encoder) kStruct(f *codecFnInfo, rv reflect.Value) {
+	fti := f.ti
+	elemsep := e.hh.hasElemSeparators()
+	tisfi := fti.sfip
+	toMap := !(fti.toArray || e.h.StructToArray)
 	// if toMap, use the sorted array. If toArray, use unsorted array (to match sequence in struct)
 	if toMap {
 		tisfi = fti.sfi
 	}
+	newlen := len(fti.sfi)
+	ee := e.e
+
+	// Use sync.Pool to reduce allocating slices unnecessarily.
+	// The cost of sync.Pool is less than the cost of new allocation.
+	//
+	// Each element of the array pools one of encStructPool(8|16|32|64).
+	// It allows the re-use of slices up to 64 in length.
+	// A performance cost of encoding structs was collecting
+	// which values were empty and should be omitted.
+	// We needed slices of reflect.Value and string to collect them.
+	// This shared pool reduces the amount of unnecessary creation we do.
+	// The cost is that of locking sometimes, but sync.Pool is efficient
+	// enough to reduce thread contention.
+
+	var spool *sync.Pool
+	var poolv interface{}
+	var fkvs []stringRv
+	if newlen <= 8 {
+		spool, poolv = pool.stringRv8()
+		fkvs = poolv.(*[8]stringRv)[:newlen]
+	} else if newlen <= 16 {
+		spool, poolv = pool.stringRv16()
+		fkvs = poolv.(*[16]stringRv)[:newlen]
+	} else if newlen <= 32 {
+		spool, poolv = pool.stringRv32()
+		fkvs = poolv.(*[32]stringRv)[:newlen]
+	} else if newlen <= 64 {
+		spool, poolv = pool.stringRv64()
+		fkvs = poolv.(*[64]stringRv)[:newlen]
+	} else if newlen <= 128 {
+		spool, poolv = pool.stringRv128()
+		fkvs = poolv.(*[128]stringRv)[:newlen]
+	} else {
+		fkvs = make([]stringRv, newlen)
+	}
+
 	newlen = 0
 	var kv stringRv
 	recur := e.h.RecursiveEmptyCheck
+	sfn := structFieldNode{v: rv, update: false}
 	for _, si := range tisfi {
-		kv.r = si.field(rv, false)
+		// kv.r = si.field(rv, false)
+		kv.r = sfn.field(si)
 		if toMap {
 			if si.omitEmpty && isEmptyValue(kv.r, recur, recur) {
 				continue
@@ -584,88 +736,69 @@ func (f *encFnInfo) kStruct(rv reflect.Value) {
 		newlen++
 	}
 
-	// debugf(">>>> kStruct: newlen: %v", newlen)
-	// sep := !e.be
-	ee := e.e //don't dereference every time
-
 	if toMap {
-		ee.EncodeMapStart(newlen)
+		ee.WriteMapStart(newlen)
 		// asSymbols := e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0
 		asSymbols := e.h.AsSymbols == AsSymbolDefault || e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0
-		for j := 0; j < newlen; j++ {
-			kv = fkvs[j]
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if !elemsep {
+			for j := 0; j < newlen; j++ {
+				kv = fkvs[j]
+				if asSymbols {
+					ee.EncodeSymbol(kv.v)
+				} else {
+					ee.EncodeString(c_UTF8, kv.v)
+				}
+				e.encodeValue(kv.r, nil, true)
 			}
-			if asSymbols {
-				ee.EncodeSymbol(kv.v)
-			} else {
-				ee.EncodeString(c_UTF8, kv.v)
+		} else {
+			for j := 0; j < newlen; j++ {
+				kv = fkvs[j]
+				ee.WriteMapElemKey()
+				if asSymbols {
+					ee.EncodeSymbol(kv.v)
+				} else {
+					ee.EncodeString(c_UTF8, kv.v)
+				}
+				ee.WriteMapElemValue()
+				e.encodeValue(kv.r, nil, true)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			e.encodeValue(kv.r, nil)
-		}
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
 		}
+		ee.WriteMapEnd()
 	} else {
-		ee.EncodeArrayStart(newlen)
-		for j := 0; j < newlen; j++ {
-			kv = fkvs[j]
-			if cr != nil {
-				cr.sendContainerState(containerArrayElem)
+		ee.WriteArrayStart(newlen)
+		if !elemsep {
+			for j := 0; j < newlen; j++ {
+				e.encodeValue(fkvs[j].r, nil, true)
+			}
+		} else {
+			for j := 0; j < newlen; j++ {
+				ee.WriteArrayElem()
+				e.encodeValue(fkvs[j].r, nil, true)
 			}
-			e.encodeValue(kv.r, nil)
-		}
-		if cr != nil {
-			cr.sendContainerState(containerArrayEnd)
 		}
+		ee.WriteArrayEnd()
 	}
 
 	// do not use defer. Instead, use explicit pool return at end of function.
 	// defer has a cost we are trying to avoid.
 	// If there is a panic and these slices are not returned, it is ok.
-	if pool != nil {
-		pool.Put(poolv)
+	if spool != nil {
+		spool.Put(poolv)
 	}
 }
 
-// func (f *encFnInfo) kPtr(rv reflect.Value) {
-// 	debugf(">>>>>>> ??? encode kPtr called - shouldn't get called")
-// 	if rv.IsNil() {
-// 		f.e.e.encodeNil()
-// 		return
-// 	}
-// 	f.e.encodeValue(rv.Elem())
-// }
-
-// func (f *encFnInfo) kInterface(rv reflect.Value) {
-// 	println("kInterface called")
-// 	debug.PrintStack()
-// 	if rv.IsNil() {
-// 		f.e.e.EncodeNil()
-// 		return
-// 	}
-// 	f.e.encodeValue(rv.Elem(), nil)
-// }
-
-func (f *encFnInfo) kMap(rv reflect.Value) {
-	ee := f.e.e
+func (e *Encoder) kMap(f *codecFnInfo, rv reflect.Value) {
+	ee := e.e
 	if rv.IsNil() {
 		ee.EncodeNil()
 		return
 	}
 
 	l := rv.Len()
-	ee.EncodeMapStart(l)
-	e := f.e
-	cr := e.cr
+	ee.WriteMapStart(l)
+	elemsep := e.hh.hasElemSeparators()
 	if l == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		ee.WriteMapEnd()
 		return
 	}
 	var asSymbols bool
@@ -676,245 +809,246 @@ func (f *encFnInfo) kMap(rv reflect.Value) {
 	// However, if kind is reflect.Interface, do not pre-determine the
 	// encoding type, because preEncodeValue may break it down to
 	// a concrete type and kInterface will bomb.
-	var keyFn, valFn *encFn
+	var keyFn, valFn *codecFn
 	ti := f.ti
-	rtkey := ti.rt.Key()
-	rtval := ti.rt.Elem()
-	rtkeyid := reflect.ValueOf(rtkey).Pointer()
-	// keyTypeIsString := f.ti.rt.Key().Kind() == reflect.String
-	var keyTypeIsString = rtkeyid == stringTypId
-	if keyTypeIsString {
-		asSymbols = e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
-	} else {
-		for rtkey.Kind() == reflect.Ptr {
-			rtkey = rtkey.Elem()
-		}
-		if rtkey.Kind() != reflect.Interface {
-			rtkeyid = reflect.ValueOf(rtkey).Pointer()
-			keyFn = e.getEncFn(rtkeyid, rtkey, true, true)
-		}
-	}
+	rtkey0 := ti.rt.Key()
+	rtkey := rtkey0
+	rtval0 := ti.rt.Elem()
+	rtval := rtval0
+	rtkeyid := rt2id(rtkey0)
+	rtvalid := rt2id(rtval0)
 	for rtval.Kind() == reflect.Ptr {
 		rtval = rtval.Elem()
 	}
 	if rtval.Kind() != reflect.Interface {
-		rtvalid := reflect.ValueOf(rtval).Pointer()
-		valFn = e.getEncFn(rtvalid, rtval, true, true)
+		valFn = e.cf.get(rtval, true, true)
 	}
 	mks := rv.MapKeys()
-	// for j, lmks := 0, len(mks); j < lmks; j++ {
 
 	if e.h.Canonical {
-		e.kMapCanonical(rtkeyid, rtkey, rv, mks, valFn, asSymbols)
+		e.kMapCanonical(rtkey, rv, mks, valFn, asSymbols)
+		ee.WriteMapEnd()
+		return
+	}
+
+	var recognizedKtyp, recognizedVtyp bool
+	var keyTypeIsString = rtkeyid == stringTypId
+	if keyTypeIsString {
+		asSymbols = e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	} else {
-		for j := range mks {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if useLookupRecognizedTypes {
+			if recognizedKtyp = isRecognizedRtidOrPtr(rtkeyid); recognizedKtyp {
+				goto LABEL1
 			}
-			if keyTypeIsString {
-				if asSymbols {
-					ee.EncodeSymbol(mks[j].String())
-				} else {
-					ee.EncodeString(c_UTF8, mks[j].String())
-				}
-			} else {
-				e.encodeValue(mks[j], keyFn)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			e.encodeValue(rv.MapIndex(mks[j]), valFn)
+		}
+		for rtkey.Kind() == reflect.Ptr {
+			rtkey = rtkey.Elem()
+		}
+		if rtkey.Kind() != reflect.Interface {
+			rtkeyid = rt2id(rtkey)
+			keyFn = e.cf.get(rtkey, true, true)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
+
+	// for j, lmks := 0, len(mks); j < lmks; j++ {
+LABEL1:
+	recognizedVtyp = useLookupRecognizedTypes && isRecognizedRtidOrPtr(rtvalid)
+	for j := range mks {
+		if elemsep {
+			ee.WriteMapElemKey()
+		}
+		if keyTypeIsString {
+			if asSymbols {
+				ee.EncodeSymbol(mks[j].String())
+			} else {
+				ee.EncodeString(c_UTF8, mks[j].String())
+			}
+		} else if useLookupRecognizedTypes && recognizedKtyp {
+			e.encode(rv2i(mks[j]))
+		} else {
+			e.encodeValue(mks[j], keyFn, true)
+		}
+		if elemsep {
+			ee.WriteMapElemValue()
+		}
+		if useLookupRecognizedTypes && recognizedVtyp {
+			e.encode(rv2i(rv.MapIndex(mks[j])))
+		} else {
+			e.encodeValue(rv.MapIndex(mks[j]), valFn, true)
+		}
 	}
+	ee.WriteMapEnd()
 }
 
-func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect.Value, mks []reflect.Value, valFn *encFn, asSymbols bool) {
+func (e *Encoder) kMapCanonical(rtkey reflect.Type, rv reflect.Value, mks []reflect.Value, valFn *codecFn, asSymbols bool) {
 	ee := e.e
-	cr := e.cr
+	elemsep := e.hh.hasElemSeparators()
 	// we previously did out-of-band if an extension was registered.
 	// This is not necessary, as the natural kind is sufficient for ordering.
 
-	if rtkeyid == uint8SliceTypId {
-		mksv := make([]bytesRv, len(mks))
+	// WHAT IS THIS? rtkeyid can never be a []uint8, per spec
+	// if rtkeyid == uint8SliceTypId {
+	// 	mksv := make([]bytesRv, len(mks))
+	// 	for i, k := range mks {
+	// 		v := &mksv[i]
+	// 		v.r = k
+	// 		v.v = k.Bytes()
+	// 	}
+	// 	sort.Sort(bytesRvSlice(mksv))
+	// 	for i := range mksv {
+	// 		if elemsep {
+	// 			ee.WriteMapElemKey()
+	// 		}
+	// 		ee.EncodeStringBytes(c_RAW, mksv[i].v)
+	// 		if elemsep {
+	// 			ee.WriteMapElemValue()
+	// 		}
+	// 		e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+	// 	}
+	// 	return
+	// }
+
+	switch rtkey.Kind() {
+	case reflect.Bool:
+		mksv := make([]boolRv, len(mks))
 		for i, k := range mks {
 			v := &mksv[i]
 			v.r = k
-			v.v = k.Bytes()
+			v.v = k.Bool()
 		}
-		sort.Sort(bytesRvSlice(mksv))
+		sort.Sort(boolRvSlice(mksv))
 		for i := range mksv {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if elemsep {
+				ee.WriteMapElemKey()
 			}
-			ee.EncodeStringBytes(c_RAW, mksv[i].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			ee.EncodeBool(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
 			}
-			e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
 		}
-	} else {
-		switch rtkey.Kind() {
-		case reflect.Bool:
-			mksv := make([]boolRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.Bool()
+	case reflect.String:
+		mksv := make([]stringRv, len(mks))
+		for i, k := range mks {
+			v := &mksv[i]
+			v.r = k
+			v.v = k.String()
+		}
+		sort.Sort(stringRvSlice(mksv))
+		for i := range mksv {
+			if elemsep {
+				ee.WriteMapElemKey()
 			}
-			sort.Sort(boolRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeBool(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
+			if asSymbols {
+				ee.EncodeSymbol(mksv[i].v)
+			} else {
+				ee.EncodeString(c_UTF8, mksv[i].v)
 			}
-		case reflect.String:
-			mksv := make([]stringRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.String()
+			if elemsep {
+				ee.WriteMapElemValue()
 			}
-			sort.Sort(stringRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				if asSymbols {
-					ee.EncodeSymbol(mksv[i].v)
-				} else {
-					ee.EncodeString(c_UTF8, mksv[i].v)
-				}
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr:
+		mksv := make([]uintRv, len(mks))
+		for i, k := range mks {
+			v := &mksv[i]
+			v.r = k
+			v.v = k.Uint()
+		}
+		sort.Sort(uintRvSlice(mksv))
+		for i := range mksv {
+			if elemsep {
+				ee.WriteMapElemKey()
 			}
-		case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr:
-			mksv := make([]uintRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.Uint()
+			ee.EncodeUint(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
 			}
-			sort.Sort(uintRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeUint(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		mksv := make([]intRv, len(mks))
+		for i, k := range mks {
+			v := &mksv[i]
+			v.r = k
+			v.v = k.Int()
+		}
+		sort.Sort(intRvSlice(mksv))
+		for i := range mksv {
+			if elemsep {
+				ee.WriteMapElemKey()
 			}
-		case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-			mksv := make([]intRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.Int()
+			ee.EncodeInt(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
 			}
-			sort.Sort(intRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeInt(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	case reflect.Float32:
+		mksv := make([]floatRv, len(mks))
+		for i, k := range mks {
+			v := &mksv[i]
+			v.r = k
+			v.v = k.Float()
+		}
+		sort.Sort(floatRvSlice(mksv))
+		for i := range mksv {
+			if elemsep {
+				ee.WriteMapElemKey()
 			}
-		case reflect.Float32:
-			mksv := make([]floatRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.Float()
+			ee.EncodeFloat32(float32(mksv[i].v))
+			if elemsep {
+				ee.WriteMapElemValue()
 			}
-			sort.Sort(floatRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeFloat32(float32(mksv[i].v))
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	case reflect.Float64:
+		mksv := make([]floatRv, len(mks))
+		for i, k := range mks {
+			v := &mksv[i]
+			v.r = k
+			v.v = k.Float()
+		}
+		sort.Sort(floatRvSlice(mksv))
+		for i := range mksv {
+			if elemsep {
+				ee.WriteMapElemKey()
 			}
-		case reflect.Float64:
-			mksv := make([]floatRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.Float()
+			ee.EncodeFloat64(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
 			}
-			sort.Sort(floatRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeFloat64(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	default:
+		// out-of-band
+		// first encode each key to a []byte first, then sort them, then record
+		var mksv []byte = make([]byte, 0, len(mks)*16) // temporary byte slice for the encoding
+		e2 := NewEncoderBytes(&mksv, e.hh)
+		mksbv := make([]bytesRv, len(mks))
+		for i, k := range mks {
+			v := &mksbv[i]
+			l := len(mksv)
+			e2.MustEncode(k)
+			v.r = k
+			v.v = mksv[l:]
+		}
+		sort.Sort(bytesRvSlice(mksbv))
+		for j := range mksbv {
+			if elemsep {
+				ee.WriteMapElemKey()
 			}
-		default:
-			// out-of-band
-			// first encode each key to a []byte first, then sort them, then record
-			var mksv []byte = make([]byte, 0, len(mks)*16) // temporary byte slice for the encoding
-			e2 := NewEncoderBytes(&mksv, e.hh)
-			mksbv := make([]bytesRv, len(mks))
-			for i, k := range mks {
-				v := &mksbv[i]
-				l := len(mksv)
-				e2.MustEncode(k)
-				v.r = k
-				v.v = mksv[l:]
-				// fmt.Printf(">>>>> %s\n", mksv[l:])
-			}
-			sort.Sort(bytesRvSlice(mksbv))
-			for j := range mksbv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				e.asis(mksbv[j].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksbv[j].r), valFn)
+			e.asis(mksbv[j].v)
+			if elemsep {
+				ee.WriteMapElemValue()
 			}
+			e.encodeValue(rv.MapIndex(mksbv[j].r), valFn, true)
 		}
 	}
 }
 
-// --------------------------------------------------
-
-// encFn encapsulates the captured variables and the encode function.
-// This way, we only do some calculations one times, and pass to the
-// code block that should be called (encapsulated in a function)
-// instead of executing the checks every time.
-type encFn struct {
-	i encFnInfo
-	f func(*encFnInfo, reflect.Value)
-}
-
-// --------------------------------------------------
-
-type encRtidFn struct {
-	rtid uintptr
-	fn   encFn
-}
+// // --------------------------------------------------
 
 // An Encoder writes an object to an output stream in the codec format.
 type Encoder struct {
@@ -922,23 +1056,26 @@ type Encoder struct {
 	e encDriver
 	// NOTE: Encoder shouldn't call it's write methods,
 	// as the handler MAY need to do some coordination.
-	w  encWriter
-	s  []encRtidFn
-	ci set
-	be bool // is binary encoding
-	js bool // is json handle
+	w encWriter
+
+	hh Handle
+	h  *BasicHandle
+
+	// ---- cpu cache line boundary?
 
 	wi ioEncWriter
 	wb bytesEncWriter
+	bw bufio.Writer
 
-	h  *BasicHandle
-	hh Handle
-
-	cr containerStateRecv
+	// cr containerStateRecv
 	as encDriverAsis
+	// ---- cpu cache line boundary?
 
-	f map[uintptr]*encFn
-	b [scratchByteArrayLen]byte
+	ci  set
+	err error
+
+	b  [scratchByteArrayLen]byte
+	cf codecFner
 }
 
 // NewEncoder returns an Encoder for encoding into an io.Writer.
@@ -963,11 +1100,10 @@ func NewEncoderBytes(out *[]byte, h Handle) *Encoder {
 }
 
 func newEncoder(h Handle) *Encoder {
-	e := &Encoder{hh: h, h: h.getBasicHandle(), be: h.isBinary()}
-	_, e.js = h.(*JsonHandle)
+	e := &Encoder{hh: h, h: h.getBasicHandle()}
 	e.e = h.newEncDriver(e)
 	e.as, _ = e.e.(encDriverAsis)
-	e.cr, _ = e.e.(containerStateRecv)
+	// e.cr, _ = e.e.(containerStateRecv)
 	return e
 }
 
@@ -976,19 +1112,29 @@ func newEncoder(h Handle) *Encoder {
 // This accommodates using the state of the Encoder,
 // where it has "cached" information about sub-engines.
 func (e *Encoder) Reset(w io.Writer) {
-	ww, ok := w.(ioEncWriterWriter)
-	if ok {
-		e.wi.w = ww
+	var ok bool
+	e.wi.w = w
+	if e.h.WriterBufferSize > 0 {
+		bw := bufio.NewWriterSize(w, e.h.WriterBufferSize)
+		e.bw = *bw
+		e.wi.bw = &e.bw
+		e.wi.sw = &e.bw
+		e.wi.fw = &e.bw
+		e.wi.ww = &e.bw
 	} else {
-		sww := &e.wi.s
-		sww.w = w
-		sww.bw, _ = w.(io.ByteWriter)
-		sww.sw, _ = w.(ioEncStringWriter)
-		e.wi.w = sww
-		//ww = bufio.NewWriterSize(w, defEncByteBufSize)
+		if e.wi.bw, ok = w.(io.ByteWriter); !ok {
+			e.wi.bw = &e.wi
+		}
+		if e.wi.sw, ok = w.(ioEncStringWriter); !ok {
+			e.wi.sw = &e.wi
+		}
+		e.wi.fw, _ = w.(ioEncFlusher)
+		e.wi.ww = w
 	}
 	e.w = &e.wi
 	e.e.reset()
+	e.cf.reset(e.hh)
+	e.err = nil
 }
 
 func (e *Encoder) ResetBytes(out *[]byte) {
@@ -999,14 +1145,10 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 	e.wb.b, e.wb.out, e.wb.c = in, out, 0
 	e.w = &e.wb
 	e.e.reset()
+	e.cf.reset(e.hh)
+	e.err = nil
 }
 
-// func (e *Encoder) sendContainerState(c containerState) {
-// 	if e.cr != nil {
-// 		e.cr.sendContainerState(c)
-// 	}
-// }
-
 // Encode writes an object into a stream.
 //
 // Encoding can be configured via the struct tag for the fields.
@@ -1027,6 +1169,8 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 // However, struct values may encode as arrays. This happens when:
 //    - StructToArray Encode option is set, OR
 //    - the tag on the _struct field sets the "toarray" option
+// Note that omitempty is ignored when encoding struct values as arrays,
+// as an entry must be encoded for each field, to maintain its position.
 //
 // Values with types that implement MapBySlice are encoded as stream maps.
 //
@@ -1053,8 +1197,7 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 //      }
 //
 //      type MyStruct struct {
-//          _struct bool    `codec:",omitempty,toarray"`   //set omitempty for every field
-//                                                         //and encode struct as an array
+//          _struct bool    `codec:",toarray"`   //encode struct as an array
 //      }
 //
 // The mode of encoding is based on the type of the value. When a value is seen:
@@ -1067,34 +1210,41 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 // Some formats support symbols (e.g. binc) and will properly encode the string
 // only once in the stream, and use a tag to refer to it thereafter.
 func (e *Encoder) Encode(v interface{}) (err error) {
-	defer panicToErr(&err)
-	e.encode(v)
-	e.w.atEndOfEncode()
+	defer panicToErrs2(&e.err, &err)
+	e.MustEncode(v)
 	return
 }
 
 // MustEncode is like Encode, but panics if unable to Encode.
 // This provides insight to the code location that triggered the error.
 func (e *Encoder) MustEncode(v interface{}) {
+	if e.err != nil {
+		panic(e.err)
+	}
 	e.encode(v)
+	e.e.atEndOfEncode()
 	e.w.atEndOfEncode()
 }
 
 func (e *Encoder) encode(iv interface{}) {
-	// if ics, ok := iv.(Selfer); ok {
-	// 	ics.CodecEncodeSelf(e)
-	// 	return
-	// }
+	if iv == nil || definitelyNil(iv) {
+		e.e.EncodeNil()
+		return
+	}
+	if v, ok := iv.(Selfer); ok {
+		v.CodecEncodeSelf(e)
+		return
+	}
 
 	switch v := iv.(type) {
-	case nil:
-		e.e.EncodeNil()
-	case Selfer:
-		v.CodecEncodeSelf(e)
+	// case nil:
+	// 	e.e.EncodeNil()
+	// case Selfer:
+	// 	v.CodecEncodeSelf(e)
 	case Raw:
-		e.raw(v)
+		e.rawBytes(v)
 	case reflect.Value:
-		e.encodeValue(v, nil)
+		e.encodeValue(v, nil, true)
 
 	case string:
 		e.e.EncodeString(c_UTF8, v)
@@ -1120,6 +1270,8 @@ func (e *Encoder) encode(iv interface{}) {
 		e.e.EncodeUint(uint64(v))
 	case uint64:
 		e.e.EncodeUint(v)
+	case uintptr:
+		e.e.EncodeUint(uint64(v))
 	case float32:
 		e.e.EncodeFloat32(v)
 	case float64:
@@ -1152,6 +1304,8 @@ func (e *Encoder) encode(iv interface{}) {
 		e.e.EncodeUint(uint64(*v))
 	case *uint64:
 		e.e.EncodeUint(*v)
+	case *uintptr:
+		e.e.EncodeUint(uint64(*v))
 	case *float32:
 		e.e.EncodeFloat32(*v)
 	case *float64:
@@ -1161,15 +1315,15 @@ func (e *Encoder) encode(iv interface{}) {
 		e.e.EncodeStringBytes(c_RAW, *v)
 
 	default:
-		const checkCodecSelfer1 = true // in case T is passed, where *T is a Selfer, still checkCodecSelfer
 		if !fastpathEncodeTypeSwitch(iv, e) {
-			e.encodeI(iv, false, checkCodecSelfer1)
+			e.encodeValue(reflect.ValueOf(iv), nil, false)
 		}
 	}
 }
 
-func (e *Encoder) preEncodeValue(rv reflect.Value) (rv2 reflect.Value, sptr uintptr, proceed bool) {
-	// use a goto statement instead of a recursive function for ptr/interface.
+func (e *Encoder) encodeValue(rv reflect.Value, fn *codecFn, checkFastpath bool) {
+	// if a valid fn is passed, it MUST BE for the dereferenced type of rv
+	var sptr uintptr
 TOP:
 	switch rv.Kind() {
 	case reflect.Ptr:
@@ -1201,167 +1355,26 @@ TOP:
 		return
 	}
 
-	proceed = true
-	rv2 = rv
-	return
-}
-
-func (e *Encoder) doEncodeValue(rv reflect.Value, fn *encFn, sptr uintptr,
-	checkFastpath, checkCodecSelfer bool) {
-	if sptr != 0 {
-		if (&e.ci).add(sptr) {
-			e.errorf("circular reference found: # %d", sptr)
-		}
+	if sptr != 0 && (&e.ci).add(sptr) {
+		e.errorf("circular reference found: # %d", sptr)
 	}
+
 	if fn == nil {
 		rt := rv.Type()
-		rtid := reflect.ValueOf(rt).Pointer()
-		// fn = e.getEncFn(rtid, rt, true, true)
-		fn = e.getEncFn(rtid, rt, checkFastpath, checkCodecSelfer)
+		// TODO: calling isRecognizedRtid here is a major slowdown
+		if false && useLookupRecognizedTypes && isRecognizedRtidOrPtr(rt2id(rt)) {
+			e.encode(rv2i(rv))
+			return
+		}
+		// always pass checkCodecSelfer=true, in case T or ****T is passed, where *T is a Selfer
+		fn = e.cf.get(rt, checkFastpath, true)
 	}
-	fn.f(&fn.i, rv)
+	fn.fe(e, &fn.i, rv)
 	if sptr != 0 {
 		(&e.ci).remove(sptr)
 	}
 }
 
-func (e *Encoder) encodeI(iv interface{}, checkFastpath, checkCodecSelfer bool) {
-	if rv, sptr, proceed := e.preEncodeValue(reflect.ValueOf(iv)); proceed {
-		e.doEncodeValue(rv, nil, sptr, checkFastpath, checkCodecSelfer)
-	}
-}
-
-func (e *Encoder) encodeValue(rv reflect.Value, fn *encFn) {
-	// if a valid fn is passed, it MUST BE for the dereferenced type of rv
-	if rv, sptr, proceed := e.preEncodeValue(rv); proceed {
-		e.doEncodeValue(rv, fn, sptr, true, true)
-	}
-}
-
-func (e *Encoder) getEncFn(rtid uintptr, rt reflect.Type, checkFastpath, checkCodecSelfer bool) (fn *encFn) {
-	// rtid := reflect.ValueOf(rt).Pointer()
-	var ok bool
-	if useMapForCodecCache {
-		fn, ok = e.f[rtid]
-	} else {
-		for i := range e.s {
-			v := &(e.s[i])
-			if v.rtid == rtid {
-				fn, ok = &(v.fn), true
-				break
-			}
-		}
-	}
-	if ok {
-		return
-	}
-
-	if useMapForCodecCache {
-		if e.f == nil {
-			e.f = make(map[uintptr]*encFn, initCollectionCap)
-		}
-		fn = new(encFn)
-		e.f[rtid] = fn
-	} else {
-		if e.s == nil {
-			e.s = make([]encRtidFn, 0, initCollectionCap)
-		}
-		e.s = append(e.s, encRtidFn{rtid: rtid})
-		fn = &(e.s[len(e.s)-1]).fn
-	}
-
-	ti := e.h.getTypeInfo(rtid, rt)
-	fi := &(fn.i)
-	fi.e = e
-	fi.ti = ti
-
-	if checkCodecSelfer && ti.cs {
-		fn.f = (*encFnInfo).selferMarshal
-	} else if rtid == rawTypId {
-		fn.f = (*encFnInfo).raw
-	} else if rtid == rawExtTypId {
-		fn.f = (*encFnInfo).rawExt
-	} else if e.e.IsBuiltinType(rtid) {
-		fn.f = (*encFnInfo).builtin
-	} else if xfFn := e.h.getExt(rtid); xfFn != nil {
-		fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
-		fn.f = (*encFnInfo).ext
-	} else if supportMarshalInterfaces && e.be && ti.bm {
-		fn.f = (*encFnInfo).binaryMarshal
-	} else if supportMarshalInterfaces && !e.be && e.js && ti.jm {
-		//If JSON, we should check JSONMarshal before textMarshal
-		fn.f = (*encFnInfo).jsonMarshal
-	} else if supportMarshalInterfaces && !e.be && ti.tm {
-		fn.f = (*encFnInfo).textMarshal
-	} else {
-		rk := rt.Kind()
-		if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) {
-			if rt.PkgPath() == "" { // un-named slice or map
-				if idx := fastpathAV.index(rtid); idx != -1 {
-					fn.f = fastpathAV[idx].encfn
-				}
-			} else {
-				ok = false
-				// use mapping for underlying type if there
-				var rtu reflect.Type
-				if rk == reflect.Map {
-					rtu = reflect.MapOf(rt.Key(), rt.Elem())
-				} else {
-					rtu = reflect.SliceOf(rt.Elem())
-				}
-				rtuid := reflect.ValueOf(rtu).Pointer()
-				if idx := fastpathAV.index(rtuid); idx != -1 {
-					xfnf := fastpathAV[idx].encfn
-					xrt := fastpathAV[idx].rt
-					fn.f = func(xf *encFnInfo, xrv reflect.Value) {
-						xfnf(xf, xrv.Convert(xrt))
-					}
-				}
-			}
-		}
-		if fn.f == nil {
-			switch rk {
-			case reflect.Bool:
-				fn.f = (*encFnInfo).kBool
-			case reflect.String:
-				fn.f = (*encFnInfo).kString
-			case reflect.Float64:
-				fn.f = (*encFnInfo).kFloat64
-			case reflect.Float32:
-				fn.f = (*encFnInfo).kFloat32
-			case reflect.Int, reflect.Int8, reflect.Int64, reflect.Int32, reflect.Int16:
-				fn.f = (*encFnInfo).kInt
-			case reflect.Uint8, reflect.Uint64, reflect.Uint, reflect.Uint32, reflect.Uint16, reflect.Uintptr:
-				fn.f = (*encFnInfo).kUint
-			case reflect.Invalid:
-				fn.f = (*encFnInfo).kInvalid
-			case reflect.Chan:
-				fi.seq = seqTypeChan
-				fn.f = (*encFnInfo).kSlice
-			case reflect.Slice:
-				fi.seq = seqTypeSlice
-				fn.f = (*encFnInfo).kSlice
-			case reflect.Array:
-				fi.seq = seqTypeArray
-				fn.f = (*encFnInfo).kSlice
-			case reflect.Struct:
-				fn.f = (*encFnInfo).kStruct
-				// reflect.Ptr and reflect.Interface are handled already by preEncodeValue
-				// case reflect.Ptr:
-				// 	fn.f = (*encFnInfo).kPtr
-				// case reflect.Interface:
-				// 	fn.f = (*encFnInfo).kInterface
-			case reflect.Map:
-				fn.f = (*encFnInfo).kMap
-			default:
-				fn.f = (*encFnInfo).kErr
-			}
-		}
-	}
-
-	return
-}
-
 func (e *Encoder) marshal(bs []byte, fnerr error, asis bool, c charEncoding) {
 	if fnerr != nil {
 		panic(fnerr)
@@ -1383,7 +1396,7 @@ func (e *Encoder) asis(v []byte) {
 	}
 }
 
-func (e *Encoder) raw(vv Raw) {
+func (e *Encoder) rawBytes(vv Raw) {
 	v := []byte(vv)
 	if !e.h.Raw {
 		e.errorf("Raw values cannot be encoded: %v", v)
@@ -1399,63 +1412,3 @@ func (e *Encoder) errorf(format string, params ...interface{}) {
 	err := fmt.Errorf(format, params...)
 	panic(err)
 }
-
-// ----------------------------------------
-
-const encStructPoolLen = 5
-
-// encStructPool is an array of sync.Pool.
-// Each element of the array pools one of encStructPool(8|16|32|64).
-// It allows the re-use of slices up to 64 in length.
-// A performance cost of encoding structs was collecting
-// which values were empty and should be omitted.
-// We needed slices of reflect.Value and string to collect them.
-// This shared pool reduces the amount of unnecessary creation we do.
-// The cost is that of locking sometimes, but sync.Pool is efficient
-// enough to reduce thread contention.
-var encStructPool [encStructPoolLen]sync.Pool
-
-func init() {
-	encStructPool[0].New = func() interface{} { return new([8]stringRv) }
-	encStructPool[1].New = func() interface{} { return new([16]stringRv) }
-	encStructPool[2].New = func() interface{} { return new([32]stringRv) }
-	encStructPool[3].New = func() interface{} { return new([64]stringRv) }
-	encStructPool[4].New = func() interface{} { return new([128]stringRv) }
-}
-
-func encStructPoolGet(newlen int) (p *sync.Pool, v interface{}, s []stringRv) {
-	// if encStructPoolLen != 5 { // constant chec, so removed at build time.
-	// 	panic(errors.New("encStructPoolLen must be equal to 4")) // defensive, in case it is changed
-	// }
-	// idxpool := newlen / 8
-	if newlen <= 8 {
-		p = &encStructPool[0]
-		v = p.Get()
-		s = v.(*[8]stringRv)[:newlen]
-	} else if newlen <= 16 {
-		p = &encStructPool[1]
-		v = p.Get()
-		s = v.(*[16]stringRv)[:newlen]
-	} else if newlen <= 32 {
-		p = &encStructPool[2]
-		v = p.Get()
-		s = v.(*[32]stringRv)[:newlen]
-	} else if newlen <= 64 {
-		p = &encStructPool[3]
-		v = p.Get()
-		s = v.(*[64]stringRv)[:newlen]
-	} else if newlen <= 128 {
-		p = &encStructPool[4]
-		v = p.Get()
-		s = v.(*[128]stringRv)[:newlen]
-	} else {
-		s = make([]stringRv, newlen)
-	}
-	return
-}
-
-// ----------------------------------------
-
-// func encErr(format string, params ...interface{}) {
-// 	doPanic(msgTagEnc, format, params...)
-// }
diff --git a/vendor/github.com/ugorji/go/codec/fast-path.generated.go b/vendor/github.com/ugorji/go/codec/fast-path.generated.go
index f2e5d2dcf66..69b11fcf673 100644
--- a/vendor/github.com/ugorji/go/codec/fast-path.generated.go
+++ b/vendor/github.com/ugorji/go/codec/fast-path.generated.go
@@ -40,9 +40,6 @@ import (
 
 const fastpathEnabled = true
 
-const fastpathCheckNilFalse = false // for reflect
-const fastpathCheckNilTrue = true   // for type switch
-
 type fastpathT struct{}
 
 var fastpathTV fastpathT
@@ -50,8 +47,8 @@ var fastpathTV fastpathT
 type fastpathE struct {
 	rtid  uintptr
 	rt    reflect.Type
-	encfn func(*encFnInfo, reflect.Value)
-	decfn func(*decFnInfo, reflect.Value)
+	encfn func(*Encoder, *codecFnInfo, reflect.Value)
+	decfn func(*Decoder, *codecFnInfo, reflect.Value)
 }
 
 type fastpathA [271]fastpathE
@@ -84,286 +81,292 @@ var fastpathAV fastpathA
 // due to possible initialization loop error, make fastpath in an init()
 func init() {
 	i := 0
-	fn := func(v interface{}, fe func(*encFnInfo, reflect.Value), fd func(*decFnInfo, reflect.Value)) (f fastpathE) {
+	fn := func(v interface{},
+		fe func(*Encoder, *codecFnInfo, reflect.Value),
+		fd func(*Decoder, *codecFnInfo, reflect.Value)) (f fastpathE) {
 		xrt := reflect.TypeOf(v)
-		xptr := reflect.ValueOf(xrt).Pointer()
+		xptr := rt2id(xrt)
+		if useLookupRecognizedTypes {
+			recognizedRtids = append(recognizedRtids, xptr)
+			recognizedRtidPtrs = append(recognizedRtidPtrs, rt2id(reflect.PtrTo(xrt)))
+		}
 		fastpathAV[i] = fastpathE{xptr, xrt, fe, fd}
 		i++
 		return
 	}
 
-	fn([]interface{}(nil), (*encFnInfo).fastpathEncSliceIntfR, (*decFnInfo).fastpathDecSliceIntfR)
-	fn([]string(nil), (*encFnInfo).fastpathEncSliceStringR, (*decFnInfo).fastpathDecSliceStringR)
-	fn([]float32(nil), (*encFnInfo).fastpathEncSliceFloat32R, (*decFnInfo).fastpathDecSliceFloat32R)
-	fn([]float64(nil), (*encFnInfo).fastpathEncSliceFloat64R, (*decFnInfo).fastpathDecSliceFloat64R)
-	fn([]uint(nil), (*encFnInfo).fastpathEncSliceUintR, (*decFnInfo).fastpathDecSliceUintR)
-	fn([]uint16(nil), (*encFnInfo).fastpathEncSliceUint16R, (*decFnInfo).fastpathDecSliceUint16R)
-	fn([]uint32(nil), (*encFnInfo).fastpathEncSliceUint32R, (*decFnInfo).fastpathDecSliceUint32R)
-	fn([]uint64(nil), (*encFnInfo).fastpathEncSliceUint64R, (*decFnInfo).fastpathDecSliceUint64R)
-	fn([]uintptr(nil), (*encFnInfo).fastpathEncSliceUintptrR, (*decFnInfo).fastpathDecSliceUintptrR)
-	fn([]int(nil), (*encFnInfo).fastpathEncSliceIntR, (*decFnInfo).fastpathDecSliceIntR)
-	fn([]int8(nil), (*encFnInfo).fastpathEncSliceInt8R, (*decFnInfo).fastpathDecSliceInt8R)
-	fn([]int16(nil), (*encFnInfo).fastpathEncSliceInt16R, (*decFnInfo).fastpathDecSliceInt16R)
-	fn([]int32(nil), (*encFnInfo).fastpathEncSliceInt32R, (*decFnInfo).fastpathDecSliceInt32R)
-	fn([]int64(nil), (*encFnInfo).fastpathEncSliceInt64R, (*decFnInfo).fastpathDecSliceInt64R)
-	fn([]bool(nil), (*encFnInfo).fastpathEncSliceBoolR, (*decFnInfo).fastpathDecSliceBoolR)
+	fn([]interface{}(nil), (*Encoder).fastpathEncSliceIntfR, (*Decoder).fastpathDecSliceIntfR)
+	fn([]string(nil), (*Encoder).fastpathEncSliceStringR, (*Decoder).fastpathDecSliceStringR)
+	fn([]float32(nil), (*Encoder).fastpathEncSliceFloat32R, (*Decoder).fastpathDecSliceFloat32R)
+	fn([]float64(nil), (*Encoder).fastpathEncSliceFloat64R, (*Decoder).fastpathDecSliceFloat64R)
+	fn([]uint(nil), (*Encoder).fastpathEncSliceUintR, (*Decoder).fastpathDecSliceUintR)
+	fn([]uint16(nil), (*Encoder).fastpathEncSliceUint16R, (*Decoder).fastpathDecSliceUint16R)
+	fn([]uint32(nil), (*Encoder).fastpathEncSliceUint32R, (*Decoder).fastpathDecSliceUint32R)
+	fn([]uint64(nil), (*Encoder).fastpathEncSliceUint64R, (*Decoder).fastpathDecSliceUint64R)
+	fn([]uintptr(nil), (*Encoder).fastpathEncSliceUintptrR, (*Decoder).fastpathDecSliceUintptrR)
+	fn([]int(nil), (*Encoder).fastpathEncSliceIntR, (*Decoder).fastpathDecSliceIntR)
+	fn([]int8(nil), (*Encoder).fastpathEncSliceInt8R, (*Decoder).fastpathDecSliceInt8R)
+	fn([]int16(nil), (*Encoder).fastpathEncSliceInt16R, (*Decoder).fastpathDecSliceInt16R)
+	fn([]int32(nil), (*Encoder).fastpathEncSliceInt32R, (*Decoder).fastpathDecSliceInt32R)
+	fn([]int64(nil), (*Encoder).fastpathEncSliceInt64R, (*Decoder).fastpathDecSliceInt64R)
+	fn([]bool(nil), (*Encoder).fastpathEncSliceBoolR, (*Decoder).fastpathDecSliceBoolR)
 
-	fn(map[interface{}]interface{}(nil), (*encFnInfo).fastpathEncMapIntfIntfR, (*decFnInfo).fastpathDecMapIntfIntfR)
-	fn(map[interface{}]string(nil), (*encFnInfo).fastpathEncMapIntfStringR, (*decFnInfo).fastpathDecMapIntfStringR)
-	fn(map[interface{}]uint(nil), (*encFnInfo).fastpathEncMapIntfUintR, (*decFnInfo).fastpathDecMapIntfUintR)
-	fn(map[interface{}]uint8(nil), (*encFnInfo).fastpathEncMapIntfUint8R, (*decFnInfo).fastpathDecMapIntfUint8R)
-	fn(map[interface{}]uint16(nil), (*encFnInfo).fastpathEncMapIntfUint16R, (*decFnInfo).fastpathDecMapIntfUint16R)
-	fn(map[interface{}]uint32(nil), (*encFnInfo).fastpathEncMapIntfUint32R, (*decFnInfo).fastpathDecMapIntfUint32R)
-	fn(map[interface{}]uint64(nil), (*encFnInfo).fastpathEncMapIntfUint64R, (*decFnInfo).fastpathDecMapIntfUint64R)
-	fn(map[interface{}]uintptr(nil), (*encFnInfo).fastpathEncMapIntfUintptrR, (*decFnInfo).fastpathDecMapIntfUintptrR)
-	fn(map[interface{}]int(nil), (*encFnInfo).fastpathEncMapIntfIntR, (*decFnInfo).fastpathDecMapIntfIntR)
-	fn(map[interface{}]int8(nil), (*encFnInfo).fastpathEncMapIntfInt8R, (*decFnInfo).fastpathDecMapIntfInt8R)
-	fn(map[interface{}]int16(nil), (*encFnInfo).fastpathEncMapIntfInt16R, (*decFnInfo).fastpathDecMapIntfInt16R)
-	fn(map[interface{}]int32(nil), (*encFnInfo).fastpathEncMapIntfInt32R, (*decFnInfo).fastpathDecMapIntfInt32R)
-	fn(map[interface{}]int64(nil), (*encFnInfo).fastpathEncMapIntfInt64R, (*decFnInfo).fastpathDecMapIntfInt64R)
-	fn(map[interface{}]float32(nil), (*encFnInfo).fastpathEncMapIntfFloat32R, (*decFnInfo).fastpathDecMapIntfFloat32R)
-	fn(map[interface{}]float64(nil), (*encFnInfo).fastpathEncMapIntfFloat64R, (*decFnInfo).fastpathDecMapIntfFloat64R)
-	fn(map[interface{}]bool(nil), (*encFnInfo).fastpathEncMapIntfBoolR, (*decFnInfo).fastpathDecMapIntfBoolR)
-	fn(map[string]interface{}(nil), (*encFnInfo).fastpathEncMapStringIntfR, (*decFnInfo).fastpathDecMapStringIntfR)
-	fn(map[string]string(nil), (*encFnInfo).fastpathEncMapStringStringR, (*decFnInfo).fastpathDecMapStringStringR)
-	fn(map[string]uint(nil), (*encFnInfo).fastpathEncMapStringUintR, (*decFnInfo).fastpathDecMapStringUintR)
-	fn(map[string]uint8(nil), (*encFnInfo).fastpathEncMapStringUint8R, (*decFnInfo).fastpathDecMapStringUint8R)
-	fn(map[string]uint16(nil), (*encFnInfo).fastpathEncMapStringUint16R, (*decFnInfo).fastpathDecMapStringUint16R)
-	fn(map[string]uint32(nil), (*encFnInfo).fastpathEncMapStringUint32R, (*decFnInfo).fastpathDecMapStringUint32R)
-	fn(map[string]uint64(nil), (*encFnInfo).fastpathEncMapStringUint64R, (*decFnInfo).fastpathDecMapStringUint64R)
-	fn(map[string]uintptr(nil), (*encFnInfo).fastpathEncMapStringUintptrR, (*decFnInfo).fastpathDecMapStringUintptrR)
-	fn(map[string]int(nil), (*encFnInfo).fastpathEncMapStringIntR, (*decFnInfo).fastpathDecMapStringIntR)
-	fn(map[string]int8(nil), (*encFnInfo).fastpathEncMapStringInt8R, (*decFnInfo).fastpathDecMapStringInt8R)
-	fn(map[string]int16(nil), (*encFnInfo).fastpathEncMapStringInt16R, (*decFnInfo).fastpathDecMapStringInt16R)
-	fn(map[string]int32(nil), (*encFnInfo).fastpathEncMapStringInt32R, (*decFnInfo).fastpathDecMapStringInt32R)
-	fn(map[string]int64(nil), (*encFnInfo).fastpathEncMapStringInt64R, (*decFnInfo).fastpathDecMapStringInt64R)
-	fn(map[string]float32(nil), (*encFnInfo).fastpathEncMapStringFloat32R, (*decFnInfo).fastpathDecMapStringFloat32R)
-	fn(map[string]float64(nil), (*encFnInfo).fastpathEncMapStringFloat64R, (*decFnInfo).fastpathDecMapStringFloat64R)
-	fn(map[string]bool(nil), (*encFnInfo).fastpathEncMapStringBoolR, (*decFnInfo).fastpathDecMapStringBoolR)
-	fn(map[float32]interface{}(nil), (*encFnInfo).fastpathEncMapFloat32IntfR, (*decFnInfo).fastpathDecMapFloat32IntfR)
-	fn(map[float32]string(nil), (*encFnInfo).fastpathEncMapFloat32StringR, (*decFnInfo).fastpathDecMapFloat32StringR)
-	fn(map[float32]uint(nil), (*encFnInfo).fastpathEncMapFloat32UintR, (*decFnInfo).fastpathDecMapFloat32UintR)
-	fn(map[float32]uint8(nil), (*encFnInfo).fastpathEncMapFloat32Uint8R, (*decFnInfo).fastpathDecMapFloat32Uint8R)
-	fn(map[float32]uint16(nil), (*encFnInfo).fastpathEncMapFloat32Uint16R, (*decFnInfo).fastpathDecMapFloat32Uint16R)
-	fn(map[float32]uint32(nil), (*encFnInfo).fastpathEncMapFloat32Uint32R, (*decFnInfo).fastpathDecMapFloat32Uint32R)
-	fn(map[float32]uint64(nil), (*encFnInfo).fastpathEncMapFloat32Uint64R, (*decFnInfo).fastpathDecMapFloat32Uint64R)
-	fn(map[float32]uintptr(nil), (*encFnInfo).fastpathEncMapFloat32UintptrR, (*decFnInfo).fastpathDecMapFloat32UintptrR)
-	fn(map[float32]int(nil), (*encFnInfo).fastpathEncMapFloat32IntR, (*decFnInfo).fastpathDecMapFloat32IntR)
-	fn(map[float32]int8(nil), (*encFnInfo).fastpathEncMapFloat32Int8R, (*decFnInfo).fastpathDecMapFloat32Int8R)
-	fn(map[float32]int16(nil), (*encFnInfo).fastpathEncMapFloat32Int16R, (*decFnInfo).fastpathDecMapFloat32Int16R)
-	fn(map[float32]int32(nil), (*encFnInfo).fastpathEncMapFloat32Int32R, (*decFnInfo).fastpathDecMapFloat32Int32R)
-	fn(map[float32]int64(nil), (*encFnInfo).fastpathEncMapFloat32Int64R, (*decFnInfo).fastpathDecMapFloat32Int64R)
-	fn(map[float32]float32(nil), (*encFnInfo).fastpathEncMapFloat32Float32R, (*decFnInfo).fastpathDecMapFloat32Float32R)
-	fn(map[float32]float64(nil), (*encFnInfo).fastpathEncMapFloat32Float64R, (*decFnInfo).fastpathDecMapFloat32Float64R)
-	fn(map[float32]bool(nil), (*encFnInfo).fastpathEncMapFloat32BoolR, (*decFnInfo).fastpathDecMapFloat32BoolR)
-	fn(map[float64]interface{}(nil), (*encFnInfo).fastpathEncMapFloat64IntfR, (*decFnInfo).fastpathDecMapFloat64IntfR)
-	fn(map[float64]string(nil), (*encFnInfo).fastpathEncMapFloat64StringR, (*decFnInfo).fastpathDecMapFloat64StringR)
-	fn(map[float64]uint(nil), (*encFnInfo).fastpathEncMapFloat64UintR, (*decFnInfo).fastpathDecMapFloat64UintR)
-	fn(map[float64]uint8(nil), (*encFnInfo).fastpathEncMapFloat64Uint8R, (*decFnInfo).fastpathDecMapFloat64Uint8R)
-	fn(map[float64]uint16(nil), (*encFnInfo).fastpathEncMapFloat64Uint16R, (*decFnInfo).fastpathDecMapFloat64Uint16R)
-	fn(map[float64]uint32(nil), (*encFnInfo).fastpathEncMapFloat64Uint32R, (*decFnInfo).fastpathDecMapFloat64Uint32R)
-	fn(map[float64]uint64(nil), (*encFnInfo).fastpathEncMapFloat64Uint64R, (*decFnInfo).fastpathDecMapFloat64Uint64R)
-	fn(map[float64]uintptr(nil), (*encFnInfo).fastpathEncMapFloat64UintptrR, (*decFnInfo).fastpathDecMapFloat64UintptrR)
-	fn(map[float64]int(nil), (*encFnInfo).fastpathEncMapFloat64IntR, (*decFnInfo).fastpathDecMapFloat64IntR)
-	fn(map[float64]int8(nil), (*encFnInfo).fastpathEncMapFloat64Int8R, (*decFnInfo).fastpathDecMapFloat64Int8R)
-	fn(map[float64]int16(nil), (*encFnInfo).fastpathEncMapFloat64Int16R, (*decFnInfo).fastpathDecMapFloat64Int16R)
-	fn(map[float64]int32(nil), (*encFnInfo).fastpathEncMapFloat64Int32R, (*decFnInfo).fastpathDecMapFloat64Int32R)
-	fn(map[float64]int64(nil), (*encFnInfo).fastpathEncMapFloat64Int64R, (*decFnInfo).fastpathDecMapFloat64Int64R)
-	fn(map[float64]float32(nil), (*encFnInfo).fastpathEncMapFloat64Float32R, (*decFnInfo).fastpathDecMapFloat64Float32R)
-	fn(map[float64]float64(nil), (*encFnInfo).fastpathEncMapFloat64Float64R, (*decFnInfo).fastpathDecMapFloat64Float64R)
-	fn(map[float64]bool(nil), (*encFnInfo).fastpathEncMapFloat64BoolR, (*decFnInfo).fastpathDecMapFloat64BoolR)
-	fn(map[uint]interface{}(nil), (*encFnInfo).fastpathEncMapUintIntfR, (*decFnInfo).fastpathDecMapUintIntfR)
-	fn(map[uint]string(nil), (*encFnInfo).fastpathEncMapUintStringR, (*decFnInfo).fastpathDecMapUintStringR)
-	fn(map[uint]uint(nil), (*encFnInfo).fastpathEncMapUintUintR, (*decFnInfo).fastpathDecMapUintUintR)
-	fn(map[uint]uint8(nil), (*encFnInfo).fastpathEncMapUintUint8R, (*decFnInfo).fastpathDecMapUintUint8R)
-	fn(map[uint]uint16(nil), (*encFnInfo).fastpathEncMapUintUint16R, (*decFnInfo).fastpathDecMapUintUint16R)
-	fn(map[uint]uint32(nil), (*encFnInfo).fastpathEncMapUintUint32R, (*decFnInfo).fastpathDecMapUintUint32R)
-	fn(map[uint]uint64(nil), (*encFnInfo).fastpathEncMapUintUint64R, (*decFnInfo).fastpathDecMapUintUint64R)
-	fn(map[uint]uintptr(nil), (*encFnInfo).fastpathEncMapUintUintptrR, (*decFnInfo).fastpathDecMapUintUintptrR)
-	fn(map[uint]int(nil), (*encFnInfo).fastpathEncMapUintIntR, (*decFnInfo).fastpathDecMapUintIntR)
-	fn(map[uint]int8(nil), (*encFnInfo).fastpathEncMapUintInt8R, (*decFnInfo).fastpathDecMapUintInt8R)
-	fn(map[uint]int16(nil), (*encFnInfo).fastpathEncMapUintInt16R, (*decFnInfo).fastpathDecMapUintInt16R)
-	fn(map[uint]int32(nil), (*encFnInfo).fastpathEncMapUintInt32R, (*decFnInfo).fastpathDecMapUintInt32R)
-	fn(map[uint]int64(nil), (*encFnInfo).fastpathEncMapUintInt64R, (*decFnInfo).fastpathDecMapUintInt64R)
-	fn(map[uint]float32(nil), (*encFnInfo).fastpathEncMapUintFloat32R, (*decFnInfo).fastpathDecMapUintFloat32R)
-	fn(map[uint]float64(nil), (*encFnInfo).fastpathEncMapUintFloat64R, (*decFnInfo).fastpathDecMapUintFloat64R)
-	fn(map[uint]bool(nil), (*encFnInfo).fastpathEncMapUintBoolR, (*decFnInfo).fastpathDecMapUintBoolR)
-	fn(map[uint8]interface{}(nil), (*encFnInfo).fastpathEncMapUint8IntfR, (*decFnInfo).fastpathDecMapUint8IntfR)
-	fn(map[uint8]string(nil), (*encFnInfo).fastpathEncMapUint8StringR, (*decFnInfo).fastpathDecMapUint8StringR)
-	fn(map[uint8]uint(nil), (*encFnInfo).fastpathEncMapUint8UintR, (*decFnInfo).fastpathDecMapUint8UintR)
-	fn(map[uint8]uint8(nil), (*encFnInfo).fastpathEncMapUint8Uint8R, (*decFnInfo).fastpathDecMapUint8Uint8R)
-	fn(map[uint8]uint16(nil), (*encFnInfo).fastpathEncMapUint8Uint16R, (*decFnInfo).fastpathDecMapUint8Uint16R)
-	fn(map[uint8]uint32(nil), (*encFnInfo).fastpathEncMapUint8Uint32R, (*decFnInfo).fastpathDecMapUint8Uint32R)
-	fn(map[uint8]uint64(nil), (*encFnInfo).fastpathEncMapUint8Uint64R, (*decFnInfo).fastpathDecMapUint8Uint64R)
-	fn(map[uint8]uintptr(nil), (*encFnInfo).fastpathEncMapUint8UintptrR, (*decFnInfo).fastpathDecMapUint8UintptrR)
-	fn(map[uint8]int(nil), (*encFnInfo).fastpathEncMapUint8IntR, (*decFnInfo).fastpathDecMapUint8IntR)
-	fn(map[uint8]int8(nil), (*encFnInfo).fastpathEncMapUint8Int8R, (*decFnInfo).fastpathDecMapUint8Int8R)
-	fn(map[uint8]int16(nil), (*encFnInfo).fastpathEncMapUint8Int16R, (*decFnInfo).fastpathDecMapUint8Int16R)
-	fn(map[uint8]int32(nil), (*encFnInfo).fastpathEncMapUint8Int32R, (*decFnInfo).fastpathDecMapUint8Int32R)
-	fn(map[uint8]int64(nil), (*encFnInfo).fastpathEncMapUint8Int64R, (*decFnInfo).fastpathDecMapUint8Int64R)
-	fn(map[uint8]float32(nil), (*encFnInfo).fastpathEncMapUint8Float32R, (*decFnInfo).fastpathDecMapUint8Float32R)
-	fn(map[uint8]float64(nil), (*encFnInfo).fastpathEncMapUint8Float64R, (*decFnInfo).fastpathDecMapUint8Float64R)
-	fn(map[uint8]bool(nil), (*encFnInfo).fastpathEncMapUint8BoolR, (*decFnInfo).fastpathDecMapUint8BoolR)
-	fn(map[uint16]interface{}(nil), (*encFnInfo).fastpathEncMapUint16IntfR, (*decFnInfo).fastpathDecMapUint16IntfR)
-	fn(map[uint16]string(nil), (*encFnInfo).fastpathEncMapUint16StringR, (*decFnInfo).fastpathDecMapUint16StringR)
-	fn(map[uint16]uint(nil), (*encFnInfo).fastpathEncMapUint16UintR, (*decFnInfo).fastpathDecMapUint16UintR)
-	fn(map[uint16]uint8(nil), (*encFnInfo).fastpathEncMapUint16Uint8R, (*decFnInfo).fastpathDecMapUint16Uint8R)
-	fn(map[uint16]uint16(nil), (*encFnInfo).fastpathEncMapUint16Uint16R, (*decFnInfo).fastpathDecMapUint16Uint16R)
-	fn(map[uint16]uint32(nil), (*encFnInfo).fastpathEncMapUint16Uint32R, (*decFnInfo).fastpathDecMapUint16Uint32R)
-	fn(map[uint16]uint64(nil), (*encFnInfo).fastpathEncMapUint16Uint64R, (*decFnInfo).fastpathDecMapUint16Uint64R)
-	fn(map[uint16]uintptr(nil), (*encFnInfo).fastpathEncMapUint16UintptrR, (*decFnInfo).fastpathDecMapUint16UintptrR)
-	fn(map[uint16]int(nil), (*encFnInfo).fastpathEncMapUint16IntR, (*decFnInfo).fastpathDecMapUint16IntR)
-	fn(map[uint16]int8(nil), (*encFnInfo).fastpathEncMapUint16Int8R, (*decFnInfo).fastpathDecMapUint16Int8R)
-	fn(map[uint16]int16(nil), (*encFnInfo).fastpathEncMapUint16Int16R, (*decFnInfo).fastpathDecMapUint16Int16R)
-	fn(map[uint16]int32(nil), (*encFnInfo).fastpathEncMapUint16Int32R, (*decFnInfo).fastpathDecMapUint16Int32R)
-	fn(map[uint16]int64(nil), (*encFnInfo).fastpathEncMapUint16Int64R, (*decFnInfo).fastpathDecMapUint16Int64R)
-	fn(map[uint16]float32(nil), (*encFnInfo).fastpathEncMapUint16Float32R, (*decFnInfo).fastpathDecMapUint16Float32R)
-	fn(map[uint16]float64(nil), (*encFnInfo).fastpathEncMapUint16Float64R, (*decFnInfo).fastpathDecMapUint16Float64R)
-	fn(map[uint16]bool(nil), (*encFnInfo).fastpathEncMapUint16BoolR, (*decFnInfo).fastpathDecMapUint16BoolR)
-	fn(map[uint32]interface{}(nil), (*encFnInfo).fastpathEncMapUint32IntfR, (*decFnInfo).fastpathDecMapUint32IntfR)
-	fn(map[uint32]string(nil), (*encFnInfo).fastpathEncMapUint32StringR, (*decFnInfo).fastpathDecMapUint32StringR)
-	fn(map[uint32]uint(nil), (*encFnInfo).fastpathEncMapUint32UintR, (*decFnInfo).fastpathDecMapUint32UintR)
-	fn(map[uint32]uint8(nil), (*encFnInfo).fastpathEncMapUint32Uint8R, (*decFnInfo).fastpathDecMapUint32Uint8R)
-	fn(map[uint32]uint16(nil), (*encFnInfo).fastpathEncMapUint32Uint16R, (*decFnInfo).fastpathDecMapUint32Uint16R)
-	fn(map[uint32]uint32(nil), (*encFnInfo).fastpathEncMapUint32Uint32R, (*decFnInfo).fastpathDecMapUint32Uint32R)
-	fn(map[uint32]uint64(nil), (*encFnInfo).fastpathEncMapUint32Uint64R, (*decFnInfo).fastpathDecMapUint32Uint64R)
-	fn(map[uint32]uintptr(nil), (*encFnInfo).fastpathEncMapUint32UintptrR, (*decFnInfo).fastpathDecMapUint32UintptrR)
-	fn(map[uint32]int(nil), (*encFnInfo).fastpathEncMapUint32IntR, (*decFnInfo).fastpathDecMapUint32IntR)
-	fn(map[uint32]int8(nil), (*encFnInfo).fastpathEncMapUint32Int8R, (*decFnInfo).fastpathDecMapUint32Int8R)
-	fn(map[uint32]int16(nil), (*encFnInfo).fastpathEncMapUint32Int16R, (*decFnInfo).fastpathDecMapUint32Int16R)
-	fn(map[uint32]int32(nil), (*encFnInfo).fastpathEncMapUint32Int32R, (*decFnInfo).fastpathDecMapUint32Int32R)
-	fn(map[uint32]int64(nil), (*encFnInfo).fastpathEncMapUint32Int64R, (*decFnInfo).fastpathDecMapUint32Int64R)
-	fn(map[uint32]float32(nil), (*encFnInfo).fastpathEncMapUint32Float32R, (*decFnInfo).fastpathDecMapUint32Float32R)
-	fn(map[uint32]float64(nil), (*encFnInfo).fastpathEncMapUint32Float64R, (*decFnInfo).fastpathDecMapUint32Float64R)
-	fn(map[uint32]bool(nil), (*encFnInfo).fastpathEncMapUint32BoolR, (*decFnInfo).fastpathDecMapUint32BoolR)
-	fn(map[uint64]interface{}(nil), (*encFnInfo).fastpathEncMapUint64IntfR, (*decFnInfo).fastpathDecMapUint64IntfR)
-	fn(map[uint64]string(nil), (*encFnInfo).fastpathEncMapUint64StringR, (*decFnInfo).fastpathDecMapUint64StringR)
-	fn(map[uint64]uint(nil), (*encFnInfo).fastpathEncMapUint64UintR, (*decFnInfo).fastpathDecMapUint64UintR)
-	fn(map[uint64]uint8(nil), (*encFnInfo).fastpathEncMapUint64Uint8R, (*decFnInfo).fastpathDecMapUint64Uint8R)
-	fn(map[uint64]uint16(nil), (*encFnInfo).fastpathEncMapUint64Uint16R, (*decFnInfo).fastpathDecMapUint64Uint16R)
-	fn(map[uint64]uint32(nil), (*encFnInfo).fastpathEncMapUint64Uint32R, (*decFnInfo).fastpathDecMapUint64Uint32R)
-	fn(map[uint64]uint64(nil), (*encFnInfo).fastpathEncMapUint64Uint64R, (*decFnInfo).fastpathDecMapUint64Uint64R)
-	fn(map[uint64]uintptr(nil), (*encFnInfo).fastpathEncMapUint64UintptrR, (*decFnInfo).fastpathDecMapUint64UintptrR)
-	fn(map[uint64]int(nil), (*encFnInfo).fastpathEncMapUint64IntR, (*decFnInfo).fastpathDecMapUint64IntR)
-	fn(map[uint64]int8(nil), (*encFnInfo).fastpathEncMapUint64Int8R, (*decFnInfo).fastpathDecMapUint64Int8R)
-	fn(map[uint64]int16(nil), (*encFnInfo).fastpathEncMapUint64Int16R, (*decFnInfo).fastpathDecMapUint64Int16R)
-	fn(map[uint64]int32(nil), (*encFnInfo).fastpathEncMapUint64Int32R, (*decFnInfo).fastpathDecMapUint64Int32R)
-	fn(map[uint64]int64(nil), (*encFnInfo).fastpathEncMapUint64Int64R, (*decFnInfo).fastpathDecMapUint64Int64R)
-	fn(map[uint64]float32(nil), (*encFnInfo).fastpathEncMapUint64Float32R, (*decFnInfo).fastpathDecMapUint64Float32R)
-	fn(map[uint64]float64(nil), (*encFnInfo).fastpathEncMapUint64Float64R, (*decFnInfo).fastpathDecMapUint64Float64R)
-	fn(map[uint64]bool(nil), (*encFnInfo).fastpathEncMapUint64BoolR, (*decFnInfo).fastpathDecMapUint64BoolR)
-	fn(map[uintptr]interface{}(nil), (*encFnInfo).fastpathEncMapUintptrIntfR, (*decFnInfo).fastpathDecMapUintptrIntfR)
-	fn(map[uintptr]string(nil), (*encFnInfo).fastpathEncMapUintptrStringR, (*decFnInfo).fastpathDecMapUintptrStringR)
-	fn(map[uintptr]uint(nil), (*encFnInfo).fastpathEncMapUintptrUintR, (*decFnInfo).fastpathDecMapUintptrUintR)
-	fn(map[uintptr]uint8(nil), (*encFnInfo).fastpathEncMapUintptrUint8R, (*decFnInfo).fastpathDecMapUintptrUint8R)
-	fn(map[uintptr]uint16(nil), (*encFnInfo).fastpathEncMapUintptrUint16R, (*decFnInfo).fastpathDecMapUintptrUint16R)
-	fn(map[uintptr]uint32(nil), (*encFnInfo).fastpathEncMapUintptrUint32R, (*decFnInfo).fastpathDecMapUintptrUint32R)
-	fn(map[uintptr]uint64(nil), (*encFnInfo).fastpathEncMapUintptrUint64R, (*decFnInfo).fastpathDecMapUintptrUint64R)
-	fn(map[uintptr]uintptr(nil), (*encFnInfo).fastpathEncMapUintptrUintptrR, (*decFnInfo).fastpathDecMapUintptrUintptrR)
-	fn(map[uintptr]int(nil), (*encFnInfo).fastpathEncMapUintptrIntR, (*decFnInfo).fastpathDecMapUintptrIntR)
-	fn(map[uintptr]int8(nil), (*encFnInfo).fastpathEncMapUintptrInt8R, (*decFnInfo).fastpathDecMapUintptrInt8R)
-	fn(map[uintptr]int16(nil), (*encFnInfo).fastpathEncMapUintptrInt16R, (*decFnInfo).fastpathDecMapUintptrInt16R)
-	fn(map[uintptr]int32(nil), (*encFnInfo).fastpathEncMapUintptrInt32R, (*decFnInfo).fastpathDecMapUintptrInt32R)
-	fn(map[uintptr]int64(nil), (*encFnInfo).fastpathEncMapUintptrInt64R, (*decFnInfo).fastpathDecMapUintptrInt64R)
-	fn(map[uintptr]float32(nil), (*encFnInfo).fastpathEncMapUintptrFloat32R, (*decFnInfo).fastpathDecMapUintptrFloat32R)
-	fn(map[uintptr]float64(nil), (*encFnInfo).fastpathEncMapUintptrFloat64R, (*decFnInfo).fastpathDecMapUintptrFloat64R)
-	fn(map[uintptr]bool(nil), (*encFnInfo).fastpathEncMapUintptrBoolR, (*decFnInfo).fastpathDecMapUintptrBoolR)
-	fn(map[int]interface{}(nil), (*encFnInfo).fastpathEncMapIntIntfR, (*decFnInfo).fastpathDecMapIntIntfR)
-	fn(map[int]string(nil), (*encFnInfo).fastpathEncMapIntStringR, (*decFnInfo).fastpathDecMapIntStringR)
-	fn(map[int]uint(nil), (*encFnInfo).fastpathEncMapIntUintR, (*decFnInfo).fastpathDecMapIntUintR)
-	fn(map[int]uint8(nil), (*encFnInfo).fastpathEncMapIntUint8R, (*decFnInfo).fastpathDecMapIntUint8R)
-	fn(map[int]uint16(nil), (*encFnInfo).fastpathEncMapIntUint16R, (*decFnInfo).fastpathDecMapIntUint16R)
-	fn(map[int]uint32(nil), (*encFnInfo).fastpathEncMapIntUint32R, (*decFnInfo).fastpathDecMapIntUint32R)
-	fn(map[int]uint64(nil), (*encFnInfo).fastpathEncMapIntUint64R, (*decFnInfo).fastpathDecMapIntUint64R)
-	fn(map[int]uintptr(nil), (*encFnInfo).fastpathEncMapIntUintptrR, (*decFnInfo).fastpathDecMapIntUintptrR)
-	fn(map[int]int(nil), (*encFnInfo).fastpathEncMapIntIntR, (*decFnInfo).fastpathDecMapIntIntR)
-	fn(map[int]int8(nil), (*encFnInfo).fastpathEncMapIntInt8R, (*decFnInfo).fastpathDecMapIntInt8R)
-	fn(map[int]int16(nil), (*encFnInfo).fastpathEncMapIntInt16R, (*decFnInfo).fastpathDecMapIntInt16R)
-	fn(map[int]int32(nil), (*encFnInfo).fastpathEncMapIntInt32R, (*decFnInfo).fastpathDecMapIntInt32R)
-	fn(map[int]int64(nil), (*encFnInfo).fastpathEncMapIntInt64R, (*decFnInfo).fastpathDecMapIntInt64R)
-	fn(map[int]float32(nil), (*encFnInfo).fastpathEncMapIntFloat32R, (*decFnInfo).fastpathDecMapIntFloat32R)
-	fn(map[int]float64(nil), (*encFnInfo).fastpathEncMapIntFloat64R, (*decFnInfo).fastpathDecMapIntFloat64R)
-	fn(map[int]bool(nil), (*encFnInfo).fastpathEncMapIntBoolR, (*decFnInfo).fastpathDecMapIntBoolR)
-	fn(map[int8]interface{}(nil), (*encFnInfo).fastpathEncMapInt8IntfR, (*decFnInfo).fastpathDecMapInt8IntfR)
-	fn(map[int8]string(nil), (*encFnInfo).fastpathEncMapInt8StringR, (*decFnInfo).fastpathDecMapInt8StringR)
-	fn(map[int8]uint(nil), (*encFnInfo).fastpathEncMapInt8UintR, (*decFnInfo).fastpathDecMapInt8UintR)
-	fn(map[int8]uint8(nil), (*encFnInfo).fastpathEncMapInt8Uint8R, (*decFnInfo).fastpathDecMapInt8Uint8R)
-	fn(map[int8]uint16(nil), (*encFnInfo).fastpathEncMapInt8Uint16R, (*decFnInfo).fastpathDecMapInt8Uint16R)
-	fn(map[int8]uint32(nil), (*encFnInfo).fastpathEncMapInt8Uint32R, (*decFnInfo).fastpathDecMapInt8Uint32R)
-	fn(map[int8]uint64(nil), (*encFnInfo).fastpathEncMapInt8Uint64R, (*decFnInfo).fastpathDecMapInt8Uint64R)
-	fn(map[int8]uintptr(nil), (*encFnInfo).fastpathEncMapInt8UintptrR, (*decFnInfo).fastpathDecMapInt8UintptrR)
-	fn(map[int8]int(nil), (*encFnInfo).fastpathEncMapInt8IntR, (*decFnInfo).fastpathDecMapInt8IntR)
-	fn(map[int8]int8(nil), (*encFnInfo).fastpathEncMapInt8Int8R, (*decFnInfo).fastpathDecMapInt8Int8R)
-	fn(map[int8]int16(nil), (*encFnInfo).fastpathEncMapInt8Int16R, (*decFnInfo).fastpathDecMapInt8Int16R)
-	fn(map[int8]int32(nil), (*encFnInfo).fastpathEncMapInt8Int32R, (*decFnInfo).fastpathDecMapInt8Int32R)
-	fn(map[int8]int64(nil), (*encFnInfo).fastpathEncMapInt8Int64R, (*decFnInfo).fastpathDecMapInt8Int64R)
-	fn(map[int8]float32(nil), (*encFnInfo).fastpathEncMapInt8Float32R, (*decFnInfo).fastpathDecMapInt8Float32R)
-	fn(map[int8]float64(nil), (*encFnInfo).fastpathEncMapInt8Float64R, (*decFnInfo).fastpathDecMapInt8Float64R)
-	fn(map[int8]bool(nil), (*encFnInfo).fastpathEncMapInt8BoolR, (*decFnInfo).fastpathDecMapInt8BoolR)
-	fn(map[int16]interface{}(nil), (*encFnInfo).fastpathEncMapInt16IntfR, (*decFnInfo).fastpathDecMapInt16IntfR)
-	fn(map[int16]string(nil), (*encFnInfo).fastpathEncMapInt16StringR, (*decFnInfo).fastpathDecMapInt16StringR)
-	fn(map[int16]uint(nil), (*encFnInfo).fastpathEncMapInt16UintR, (*decFnInfo).fastpathDecMapInt16UintR)
-	fn(map[int16]uint8(nil), (*encFnInfo).fastpathEncMapInt16Uint8R, (*decFnInfo).fastpathDecMapInt16Uint8R)
-	fn(map[int16]uint16(nil), (*encFnInfo).fastpathEncMapInt16Uint16R, (*decFnInfo).fastpathDecMapInt16Uint16R)
-	fn(map[int16]uint32(nil), (*encFnInfo).fastpathEncMapInt16Uint32R, (*decFnInfo).fastpathDecMapInt16Uint32R)
-	fn(map[int16]uint64(nil), (*encFnInfo).fastpathEncMapInt16Uint64R, (*decFnInfo).fastpathDecMapInt16Uint64R)
-	fn(map[int16]uintptr(nil), (*encFnInfo).fastpathEncMapInt16UintptrR, (*decFnInfo).fastpathDecMapInt16UintptrR)
-	fn(map[int16]int(nil), (*encFnInfo).fastpathEncMapInt16IntR, (*decFnInfo).fastpathDecMapInt16IntR)
-	fn(map[int16]int8(nil), (*encFnInfo).fastpathEncMapInt16Int8R, (*decFnInfo).fastpathDecMapInt16Int8R)
-	fn(map[int16]int16(nil), (*encFnInfo).fastpathEncMapInt16Int16R, (*decFnInfo).fastpathDecMapInt16Int16R)
-	fn(map[int16]int32(nil), (*encFnInfo).fastpathEncMapInt16Int32R, (*decFnInfo).fastpathDecMapInt16Int32R)
-	fn(map[int16]int64(nil), (*encFnInfo).fastpathEncMapInt16Int64R, (*decFnInfo).fastpathDecMapInt16Int64R)
-	fn(map[int16]float32(nil), (*encFnInfo).fastpathEncMapInt16Float32R, (*decFnInfo).fastpathDecMapInt16Float32R)
-	fn(map[int16]float64(nil), (*encFnInfo).fastpathEncMapInt16Float64R, (*decFnInfo).fastpathDecMapInt16Float64R)
-	fn(map[int16]bool(nil), (*encFnInfo).fastpathEncMapInt16BoolR, (*decFnInfo).fastpathDecMapInt16BoolR)
-	fn(map[int32]interface{}(nil), (*encFnInfo).fastpathEncMapInt32IntfR, (*decFnInfo).fastpathDecMapInt32IntfR)
-	fn(map[int32]string(nil), (*encFnInfo).fastpathEncMapInt32StringR, (*decFnInfo).fastpathDecMapInt32StringR)
-	fn(map[int32]uint(nil), (*encFnInfo).fastpathEncMapInt32UintR, (*decFnInfo).fastpathDecMapInt32UintR)
-	fn(map[int32]uint8(nil), (*encFnInfo).fastpathEncMapInt32Uint8R, (*decFnInfo).fastpathDecMapInt32Uint8R)
-	fn(map[int32]uint16(nil), (*encFnInfo).fastpathEncMapInt32Uint16R, (*decFnInfo).fastpathDecMapInt32Uint16R)
-	fn(map[int32]uint32(nil), (*encFnInfo).fastpathEncMapInt32Uint32R, (*decFnInfo).fastpathDecMapInt32Uint32R)
-	fn(map[int32]uint64(nil), (*encFnInfo).fastpathEncMapInt32Uint64R, (*decFnInfo).fastpathDecMapInt32Uint64R)
-	fn(map[int32]uintptr(nil), (*encFnInfo).fastpathEncMapInt32UintptrR, (*decFnInfo).fastpathDecMapInt32UintptrR)
-	fn(map[int32]int(nil), (*encFnInfo).fastpathEncMapInt32IntR, (*decFnInfo).fastpathDecMapInt32IntR)
-	fn(map[int32]int8(nil), (*encFnInfo).fastpathEncMapInt32Int8R, (*decFnInfo).fastpathDecMapInt32Int8R)
-	fn(map[int32]int16(nil), (*encFnInfo).fastpathEncMapInt32Int16R, (*decFnInfo).fastpathDecMapInt32Int16R)
-	fn(map[int32]int32(nil), (*encFnInfo).fastpathEncMapInt32Int32R, (*decFnInfo).fastpathDecMapInt32Int32R)
-	fn(map[int32]int64(nil), (*encFnInfo).fastpathEncMapInt32Int64R, (*decFnInfo).fastpathDecMapInt32Int64R)
-	fn(map[int32]float32(nil), (*encFnInfo).fastpathEncMapInt32Float32R, (*decFnInfo).fastpathDecMapInt32Float32R)
-	fn(map[int32]float64(nil), (*encFnInfo).fastpathEncMapInt32Float64R, (*decFnInfo).fastpathDecMapInt32Float64R)
-	fn(map[int32]bool(nil), (*encFnInfo).fastpathEncMapInt32BoolR, (*decFnInfo).fastpathDecMapInt32BoolR)
-	fn(map[int64]interface{}(nil), (*encFnInfo).fastpathEncMapInt64IntfR, (*decFnInfo).fastpathDecMapInt64IntfR)
-	fn(map[int64]string(nil), (*encFnInfo).fastpathEncMapInt64StringR, (*decFnInfo).fastpathDecMapInt64StringR)
-	fn(map[int64]uint(nil), (*encFnInfo).fastpathEncMapInt64UintR, (*decFnInfo).fastpathDecMapInt64UintR)
-	fn(map[int64]uint8(nil), (*encFnInfo).fastpathEncMapInt64Uint8R, (*decFnInfo).fastpathDecMapInt64Uint8R)
-	fn(map[int64]uint16(nil), (*encFnInfo).fastpathEncMapInt64Uint16R, (*decFnInfo).fastpathDecMapInt64Uint16R)
-	fn(map[int64]uint32(nil), (*encFnInfo).fastpathEncMapInt64Uint32R, (*decFnInfo).fastpathDecMapInt64Uint32R)
-	fn(map[int64]uint64(nil), (*encFnInfo).fastpathEncMapInt64Uint64R, (*decFnInfo).fastpathDecMapInt64Uint64R)
-	fn(map[int64]uintptr(nil), (*encFnInfo).fastpathEncMapInt64UintptrR, (*decFnInfo).fastpathDecMapInt64UintptrR)
-	fn(map[int64]int(nil), (*encFnInfo).fastpathEncMapInt64IntR, (*decFnInfo).fastpathDecMapInt64IntR)
-	fn(map[int64]int8(nil), (*encFnInfo).fastpathEncMapInt64Int8R, (*decFnInfo).fastpathDecMapInt64Int8R)
-	fn(map[int64]int16(nil), (*encFnInfo).fastpathEncMapInt64Int16R, (*decFnInfo).fastpathDecMapInt64Int16R)
-	fn(map[int64]int32(nil), (*encFnInfo).fastpathEncMapInt64Int32R, (*decFnInfo).fastpathDecMapInt64Int32R)
-	fn(map[int64]int64(nil), (*encFnInfo).fastpathEncMapInt64Int64R, (*decFnInfo).fastpathDecMapInt64Int64R)
-	fn(map[int64]float32(nil), (*encFnInfo).fastpathEncMapInt64Float32R, (*decFnInfo).fastpathDecMapInt64Float32R)
-	fn(map[int64]float64(nil), (*encFnInfo).fastpathEncMapInt64Float64R, (*decFnInfo).fastpathDecMapInt64Float64R)
-	fn(map[int64]bool(nil), (*encFnInfo).fastpathEncMapInt64BoolR, (*decFnInfo).fastpathDecMapInt64BoolR)
-	fn(map[bool]interface{}(nil), (*encFnInfo).fastpathEncMapBoolIntfR, (*decFnInfo).fastpathDecMapBoolIntfR)
-	fn(map[bool]string(nil), (*encFnInfo).fastpathEncMapBoolStringR, (*decFnInfo).fastpathDecMapBoolStringR)
-	fn(map[bool]uint(nil), (*encFnInfo).fastpathEncMapBoolUintR, (*decFnInfo).fastpathDecMapBoolUintR)
-	fn(map[bool]uint8(nil), (*encFnInfo).fastpathEncMapBoolUint8R, (*decFnInfo).fastpathDecMapBoolUint8R)
-	fn(map[bool]uint16(nil), (*encFnInfo).fastpathEncMapBoolUint16R, (*decFnInfo).fastpathDecMapBoolUint16R)
-	fn(map[bool]uint32(nil), (*encFnInfo).fastpathEncMapBoolUint32R, (*decFnInfo).fastpathDecMapBoolUint32R)
-	fn(map[bool]uint64(nil), (*encFnInfo).fastpathEncMapBoolUint64R, (*decFnInfo).fastpathDecMapBoolUint64R)
-	fn(map[bool]uintptr(nil), (*encFnInfo).fastpathEncMapBoolUintptrR, (*decFnInfo).fastpathDecMapBoolUintptrR)
-	fn(map[bool]int(nil), (*encFnInfo).fastpathEncMapBoolIntR, (*decFnInfo).fastpathDecMapBoolIntR)
-	fn(map[bool]int8(nil), (*encFnInfo).fastpathEncMapBoolInt8R, (*decFnInfo).fastpathDecMapBoolInt8R)
-	fn(map[bool]int16(nil), (*encFnInfo).fastpathEncMapBoolInt16R, (*decFnInfo).fastpathDecMapBoolInt16R)
-	fn(map[bool]int32(nil), (*encFnInfo).fastpathEncMapBoolInt32R, (*decFnInfo).fastpathDecMapBoolInt32R)
-	fn(map[bool]int64(nil), (*encFnInfo).fastpathEncMapBoolInt64R, (*decFnInfo).fastpathDecMapBoolInt64R)
-	fn(map[bool]float32(nil), (*encFnInfo).fastpathEncMapBoolFloat32R, (*decFnInfo).fastpathDecMapBoolFloat32R)
-	fn(map[bool]float64(nil), (*encFnInfo).fastpathEncMapBoolFloat64R, (*decFnInfo).fastpathDecMapBoolFloat64R)
-	fn(map[bool]bool(nil), (*encFnInfo).fastpathEncMapBoolBoolR, (*decFnInfo).fastpathDecMapBoolBoolR)
+	fn(map[interface{}]interface{}(nil), (*Encoder).fastpathEncMapIntfIntfR, (*Decoder).fastpathDecMapIntfIntfR)
+	fn(map[interface{}]string(nil), (*Encoder).fastpathEncMapIntfStringR, (*Decoder).fastpathDecMapIntfStringR)
+	fn(map[interface{}]uint(nil), (*Encoder).fastpathEncMapIntfUintR, (*Decoder).fastpathDecMapIntfUintR)
+	fn(map[interface{}]uint8(nil), (*Encoder).fastpathEncMapIntfUint8R, (*Decoder).fastpathDecMapIntfUint8R)
+	fn(map[interface{}]uint16(nil), (*Encoder).fastpathEncMapIntfUint16R, (*Decoder).fastpathDecMapIntfUint16R)
+	fn(map[interface{}]uint32(nil), (*Encoder).fastpathEncMapIntfUint32R, (*Decoder).fastpathDecMapIntfUint32R)
+	fn(map[interface{}]uint64(nil), (*Encoder).fastpathEncMapIntfUint64R, (*Decoder).fastpathDecMapIntfUint64R)
+	fn(map[interface{}]uintptr(nil), (*Encoder).fastpathEncMapIntfUintptrR, (*Decoder).fastpathDecMapIntfUintptrR)
+	fn(map[interface{}]int(nil), (*Encoder).fastpathEncMapIntfIntR, (*Decoder).fastpathDecMapIntfIntR)
+	fn(map[interface{}]int8(nil), (*Encoder).fastpathEncMapIntfInt8R, (*Decoder).fastpathDecMapIntfInt8R)
+	fn(map[interface{}]int16(nil), (*Encoder).fastpathEncMapIntfInt16R, (*Decoder).fastpathDecMapIntfInt16R)
+	fn(map[interface{}]int32(nil), (*Encoder).fastpathEncMapIntfInt32R, (*Decoder).fastpathDecMapIntfInt32R)
+	fn(map[interface{}]int64(nil), (*Encoder).fastpathEncMapIntfInt64R, (*Decoder).fastpathDecMapIntfInt64R)
+	fn(map[interface{}]float32(nil), (*Encoder).fastpathEncMapIntfFloat32R, (*Decoder).fastpathDecMapIntfFloat32R)
+	fn(map[interface{}]float64(nil), (*Encoder).fastpathEncMapIntfFloat64R, (*Decoder).fastpathDecMapIntfFloat64R)
+	fn(map[interface{}]bool(nil), (*Encoder).fastpathEncMapIntfBoolR, (*Decoder).fastpathDecMapIntfBoolR)
+	fn(map[string]interface{}(nil), (*Encoder).fastpathEncMapStringIntfR, (*Decoder).fastpathDecMapStringIntfR)
+	fn(map[string]string(nil), (*Encoder).fastpathEncMapStringStringR, (*Decoder).fastpathDecMapStringStringR)
+	fn(map[string]uint(nil), (*Encoder).fastpathEncMapStringUintR, (*Decoder).fastpathDecMapStringUintR)
+	fn(map[string]uint8(nil), (*Encoder).fastpathEncMapStringUint8R, (*Decoder).fastpathDecMapStringUint8R)
+	fn(map[string]uint16(nil), (*Encoder).fastpathEncMapStringUint16R, (*Decoder).fastpathDecMapStringUint16R)
+	fn(map[string]uint32(nil), (*Encoder).fastpathEncMapStringUint32R, (*Decoder).fastpathDecMapStringUint32R)
+	fn(map[string]uint64(nil), (*Encoder).fastpathEncMapStringUint64R, (*Decoder).fastpathDecMapStringUint64R)
+	fn(map[string]uintptr(nil), (*Encoder).fastpathEncMapStringUintptrR, (*Decoder).fastpathDecMapStringUintptrR)
+	fn(map[string]int(nil), (*Encoder).fastpathEncMapStringIntR, (*Decoder).fastpathDecMapStringIntR)
+	fn(map[string]int8(nil), (*Encoder).fastpathEncMapStringInt8R, (*Decoder).fastpathDecMapStringInt8R)
+	fn(map[string]int16(nil), (*Encoder).fastpathEncMapStringInt16R, (*Decoder).fastpathDecMapStringInt16R)
+	fn(map[string]int32(nil), (*Encoder).fastpathEncMapStringInt32R, (*Decoder).fastpathDecMapStringInt32R)
+	fn(map[string]int64(nil), (*Encoder).fastpathEncMapStringInt64R, (*Decoder).fastpathDecMapStringInt64R)
+	fn(map[string]float32(nil), (*Encoder).fastpathEncMapStringFloat32R, (*Decoder).fastpathDecMapStringFloat32R)
+	fn(map[string]float64(nil), (*Encoder).fastpathEncMapStringFloat64R, (*Decoder).fastpathDecMapStringFloat64R)
+	fn(map[string]bool(nil), (*Encoder).fastpathEncMapStringBoolR, (*Decoder).fastpathDecMapStringBoolR)
+	fn(map[float32]interface{}(nil), (*Encoder).fastpathEncMapFloat32IntfR, (*Decoder).fastpathDecMapFloat32IntfR)
+	fn(map[float32]string(nil), (*Encoder).fastpathEncMapFloat32StringR, (*Decoder).fastpathDecMapFloat32StringR)
+	fn(map[float32]uint(nil), (*Encoder).fastpathEncMapFloat32UintR, (*Decoder).fastpathDecMapFloat32UintR)
+	fn(map[float32]uint8(nil), (*Encoder).fastpathEncMapFloat32Uint8R, (*Decoder).fastpathDecMapFloat32Uint8R)
+	fn(map[float32]uint16(nil), (*Encoder).fastpathEncMapFloat32Uint16R, (*Decoder).fastpathDecMapFloat32Uint16R)
+	fn(map[float32]uint32(nil), (*Encoder).fastpathEncMapFloat32Uint32R, (*Decoder).fastpathDecMapFloat32Uint32R)
+	fn(map[float32]uint64(nil), (*Encoder).fastpathEncMapFloat32Uint64R, (*Decoder).fastpathDecMapFloat32Uint64R)
+	fn(map[float32]uintptr(nil), (*Encoder).fastpathEncMapFloat32UintptrR, (*Decoder).fastpathDecMapFloat32UintptrR)
+	fn(map[float32]int(nil), (*Encoder).fastpathEncMapFloat32IntR, (*Decoder).fastpathDecMapFloat32IntR)
+	fn(map[float32]int8(nil), (*Encoder).fastpathEncMapFloat32Int8R, (*Decoder).fastpathDecMapFloat32Int8R)
+	fn(map[float32]int16(nil), (*Encoder).fastpathEncMapFloat32Int16R, (*Decoder).fastpathDecMapFloat32Int16R)
+	fn(map[float32]int32(nil), (*Encoder).fastpathEncMapFloat32Int32R, (*Decoder).fastpathDecMapFloat32Int32R)
+	fn(map[float32]int64(nil), (*Encoder).fastpathEncMapFloat32Int64R, (*Decoder).fastpathDecMapFloat32Int64R)
+	fn(map[float32]float32(nil), (*Encoder).fastpathEncMapFloat32Float32R, (*Decoder).fastpathDecMapFloat32Float32R)
+	fn(map[float32]float64(nil), (*Encoder).fastpathEncMapFloat32Float64R, (*Decoder).fastpathDecMapFloat32Float64R)
+	fn(map[float32]bool(nil), (*Encoder).fastpathEncMapFloat32BoolR, (*Decoder).fastpathDecMapFloat32BoolR)
+	fn(map[float64]interface{}(nil), (*Encoder).fastpathEncMapFloat64IntfR, (*Decoder).fastpathDecMapFloat64IntfR)
+	fn(map[float64]string(nil), (*Encoder).fastpathEncMapFloat64StringR, (*Decoder).fastpathDecMapFloat64StringR)
+	fn(map[float64]uint(nil), (*Encoder).fastpathEncMapFloat64UintR, (*Decoder).fastpathDecMapFloat64UintR)
+	fn(map[float64]uint8(nil), (*Encoder).fastpathEncMapFloat64Uint8R, (*Decoder).fastpathDecMapFloat64Uint8R)
+	fn(map[float64]uint16(nil), (*Encoder).fastpathEncMapFloat64Uint16R, (*Decoder).fastpathDecMapFloat64Uint16R)
+	fn(map[float64]uint32(nil), (*Encoder).fastpathEncMapFloat64Uint32R, (*Decoder).fastpathDecMapFloat64Uint32R)
+	fn(map[float64]uint64(nil), (*Encoder).fastpathEncMapFloat64Uint64R, (*Decoder).fastpathDecMapFloat64Uint64R)
+	fn(map[float64]uintptr(nil), (*Encoder).fastpathEncMapFloat64UintptrR, (*Decoder).fastpathDecMapFloat64UintptrR)
+	fn(map[float64]int(nil), (*Encoder).fastpathEncMapFloat64IntR, (*Decoder).fastpathDecMapFloat64IntR)
+	fn(map[float64]int8(nil), (*Encoder).fastpathEncMapFloat64Int8R, (*Decoder).fastpathDecMapFloat64Int8R)
+	fn(map[float64]int16(nil), (*Encoder).fastpathEncMapFloat64Int16R, (*Decoder).fastpathDecMapFloat64Int16R)
+	fn(map[float64]int32(nil), (*Encoder).fastpathEncMapFloat64Int32R, (*Decoder).fastpathDecMapFloat64Int32R)
+	fn(map[float64]int64(nil), (*Encoder).fastpathEncMapFloat64Int64R, (*Decoder).fastpathDecMapFloat64Int64R)
+	fn(map[float64]float32(nil), (*Encoder).fastpathEncMapFloat64Float32R, (*Decoder).fastpathDecMapFloat64Float32R)
+	fn(map[float64]float64(nil), (*Encoder).fastpathEncMapFloat64Float64R, (*Decoder).fastpathDecMapFloat64Float64R)
+	fn(map[float64]bool(nil), (*Encoder).fastpathEncMapFloat64BoolR, (*Decoder).fastpathDecMapFloat64BoolR)
+	fn(map[uint]interface{}(nil), (*Encoder).fastpathEncMapUintIntfR, (*Decoder).fastpathDecMapUintIntfR)
+	fn(map[uint]string(nil), (*Encoder).fastpathEncMapUintStringR, (*Decoder).fastpathDecMapUintStringR)
+	fn(map[uint]uint(nil), (*Encoder).fastpathEncMapUintUintR, (*Decoder).fastpathDecMapUintUintR)
+	fn(map[uint]uint8(nil), (*Encoder).fastpathEncMapUintUint8R, (*Decoder).fastpathDecMapUintUint8R)
+	fn(map[uint]uint16(nil), (*Encoder).fastpathEncMapUintUint16R, (*Decoder).fastpathDecMapUintUint16R)
+	fn(map[uint]uint32(nil), (*Encoder).fastpathEncMapUintUint32R, (*Decoder).fastpathDecMapUintUint32R)
+	fn(map[uint]uint64(nil), (*Encoder).fastpathEncMapUintUint64R, (*Decoder).fastpathDecMapUintUint64R)
+	fn(map[uint]uintptr(nil), (*Encoder).fastpathEncMapUintUintptrR, (*Decoder).fastpathDecMapUintUintptrR)
+	fn(map[uint]int(nil), (*Encoder).fastpathEncMapUintIntR, (*Decoder).fastpathDecMapUintIntR)
+	fn(map[uint]int8(nil), (*Encoder).fastpathEncMapUintInt8R, (*Decoder).fastpathDecMapUintInt8R)
+	fn(map[uint]int16(nil), (*Encoder).fastpathEncMapUintInt16R, (*Decoder).fastpathDecMapUintInt16R)
+	fn(map[uint]int32(nil), (*Encoder).fastpathEncMapUintInt32R, (*Decoder).fastpathDecMapUintInt32R)
+	fn(map[uint]int64(nil), (*Encoder).fastpathEncMapUintInt64R, (*Decoder).fastpathDecMapUintInt64R)
+	fn(map[uint]float32(nil), (*Encoder).fastpathEncMapUintFloat32R, (*Decoder).fastpathDecMapUintFloat32R)
+	fn(map[uint]float64(nil), (*Encoder).fastpathEncMapUintFloat64R, (*Decoder).fastpathDecMapUintFloat64R)
+	fn(map[uint]bool(nil), (*Encoder).fastpathEncMapUintBoolR, (*Decoder).fastpathDecMapUintBoolR)
+	fn(map[uint8]interface{}(nil), (*Encoder).fastpathEncMapUint8IntfR, (*Decoder).fastpathDecMapUint8IntfR)
+	fn(map[uint8]string(nil), (*Encoder).fastpathEncMapUint8StringR, (*Decoder).fastpathDecMapUint8StringR)
+	fn(map[uint8]uint(nil), (*Encoder).fastpathEncMapUint8UintR, (*Decoder).fastpathDecMapUint8UintR)
+	fn(map[uint8]uint8(nil), (*Encoder).fastpathEncMapUint8Uint8R, (*Decoder).fastpathDecMapUint8Uint8R)
+	fn(map[uint8]uint16(nil), (*Encoder).fastpathEncMapUint8Uint16R, (*Decoder).fastpathDecMapUint8Uint16R)
+	fn(map[uint8]uint32(nil), (*Encoder).fastpathEncMapUint8Uint32R, (*Decoder).fastpathDecMapUint8Uint32R)
+	fn(map[uint8]uint64(nil), (*Encoder).fastpathEncMapUint8Uint64R, (*Decoder).fastpathDecMapUint8Uint64R)
+	fn(map[uint8]uintptr(nil), (*Encoder).fastpathEncMapUint8UintptrR, (*Decoder).fastpathDecMapUint8UintptrR)
+	fn(map[uint8]int(nil), (*Encoder).fastpathEncMapUint8IntR, (*Decoder).fastpathDecMapUint8IntR)
+	fn(map[uint8]int8(nil), (*Encoder).fastpathEncMapUint8Int8R, (*Decoder).fastpathDecMapUint8Int8R)
+	fn(map[uint8]int16(nil), (*Encoder).fastpathEncMapUint8Int16R, (*Decoder).fastpathDecMapUint8Int16R)
+	fn(map[uint8]int32(nil), (*Encoder).fastpathEncMapUint8Int32R, (*Decoder).fastpathDecMapUint8Int32R)
+	fn(map[uint8]int64(nil), (*Encoder).fastpathEncMapUint8Int64R, (*Decoder).fastpathDecMapUint8Int64R)
+	fn(map[uint8]float32(nil), (*Encoder).fastpathEncMapUint8Float32R, (*Decoder).fastpathDecMapUint8Float32R)
+	fn(map[uint8]float64(nil), (*Encoder).fastpathEncMapUint8Float64R, (*Decoder).fastpathDecMapUint8Float64R)
+	fn(map[uint8]bool(nil), (*Encoder).fastpathEncMapUint8BoolR, (*Decoder).fastpathDecMapUint8BoolR)
+	fn(map[uint16]interface{}(nil), (*Encoder).fastpathEncMapUint16IntfR, (*Decoder).fastpathDecMapUint16IntfR)
+	fn(map[uint16]string(nil), (*Encoder).fastpathEncMapUint16StringR, (*Decoder).fastpathDecMapUint16StringR)
+	fn(map[uint16]uint(nil), (*Encoder).fastpathEncMapUint16UintR, (*Decoder).fastpathDecMapUint16UintR)
+	fn(map[uint16]uint8(nil), (*Encoder).fastpathEncMapUint16Uint8R, (*Decoder).fastpathDecMapUint16Uint8R)
+	fn(map[uint16]uint16(nil), (*Encoder).fastpathEncMapUint16Uint16R, (*Decoder).fastpathDecMapUint16Uint16R)
+	fn(map[uint16]uint32(nil), (*Encoder).fastpathEncMapUint16Uint32R, (*Decoder).fastpathDecMapUint16Uint32R)
+	fn(map[uint16]uint64(nil), (*Encoder).fastpathEncMapUint16Uint64R, (*Decoder).fastpathDecMapUint16Uint64R)
+	fn(map[uint16]uintptr(nil), (*Encoder).fastpathEncMapUint16UintptrR, (*Decoder).fastpathDecMapUint16UintptrR)
+	fn(map[uint16]int(nil), (*Encoder).fastpathEncMapUint16IntR, (*Decoder).fastpathDecMapUint16IntR)
+	fn(map[uint16]int8(nil), (*Encoder).fastpathEncMapUint16Int8R, (*Decoder).fastpathDecMapUint16Int8R)
+	fn(map[uint16]int16(nil), (*Encoder).fastpathEncMapUint16Int16R, (*Decoder).fastpathDecMapUint16Int16R)
+	fn(map[uint16]int32(nil), (*Encoder).fastpathEncMapUint16Int32R, (*Decoder).fastpathDecMapUint16Int32R)
+	fn(map[uint16]int64(nil), (*Encoder).fastpathEncMapUint16Int64R, (*Decoder).fastpathDecMapUint16Int64R)
+	fn(map[uint16]float32(nil), (*Encoder).fastpathEncMapUint16Float32R, (*Decoder).fastpathDecMapUint16Float32R)
+	fn(map[uint16]float64(nil), (*Encoder).fastpathEncMapUint16Float64R, (*Decoder).fastpathDecMapUint16Float64R)
+	fn(map[uint16]bool(nil), (*Encoder).fastpathEncMapUint16BoolR, (*Decoder).fastpathDecMapUint16BoolR)
+	fn(map[uint32]interface{}(nil), (*Encoder).fastpathEncMapUint32IntfR, (*Decoder).fastpathDecMapUint32IntfR)
+	fn(map[uint32]string(nil), (*Encoder).fastpathEncMapUint32StringR, (*Decoder).fastpathDecMapUint32StringR)
+	fn(map[uint32]uint(nil), (*Encoder).fastpathEncMapUint32UintR, (*Decoder).fastpathDecMapUint32UintR)
+	fn(map[uint32]uint8(nil), (*Encoder).fastpathEncMapUint32Uint8R, (*Decoder).fastpathDecMapUint32Uint8R)
+	fn(map[uint32]uint16(nil), (*Encoder).fastpathEncMapUint32Uint16R, (*Decoder).fastpathDecMapUint32Uint16R)
+	fn(map[uint32]uint32(nil), (*Encoder).fastpathEncMapUint32Uint32R, (*Decoder).fastpathDecMapUint32Uint32R)
+	fn(map[uint32]uint64(nil), (*Encoder).fastpathEncMapUint32Uint64R, (*Decoder).fastpathDecMapUint32Uint64R)
+	fn(map[uint32]uintptr(nil), (*Encoder).fastpathEncMapUint32UintptrR, (*Decoder).fastpathDecMapUint32UintptrR)
+	fn(map[uint32]int(nil), (*Encoder).fastpathEncMapUint32IntR, (*Decoder).fastpathDecMapUint32IntR)
+	fn(map[uint32]int8(nil), (*Encoder).fastpathEncMapUint32Int8R, (*Decoder).fastpathDecMapUint32Int8R)
+	fn(map[uint32]int16(nil), (*Encoder).fastpathEncMapUint32Int16R, (*Decoder).fastpathDecMapUint32Int16R)
+	fn(map[uint32]int32(nil), (*Encoder).fastpathEncMapUint32Int32R, (*Decoder).fastpathDecMapUint32Int32R)
+	fn(map[uint32]int64(nil), (*Encoder).fastpathEncMapUint32Int64R, (*Decoder).fastpathDecMapUint32Int64R)
+	fn(map[uint32]float32(nil), (*Encoder).fastpathEncMapUint32Float32R, (*Decoder).fastpathDecMapUint32Float32R)
+	fn(map[uint32]float64(nil), (*Encoder).fastpathEncMapUint32Float64R, (*Decoder).fastpathDecMapUint32Float64R)
+	fn(map[uint32]bool(nil), (*Encoder).fastpathEncMapUint32BoolR, (*Decoder).fastpathDecMapUint32BoolR)
+	fn(map[uint64]interface{}(nil), (*Encoder).fastpathEncMapUint64IntfR, (*Decoder).fastpathDecMapUint64IntfR)
+	fn(map[uint64]string(nil), (*Encoder).fastpathEncMapUint64StringR, (*Decoder).fastpathDecMapUint64StringR)
+	fn(map[uint64]uint(nil), (*Encoder).fastpathEncMapUint64UintR, (*Decoder).fastpathDecMapUint64UintR)
+	fn(map[uint64]uint8(nil), (*Encoder).fastpathEncMapUint64Uint8R, (*Decoder).fastpathDecMapUint64Uint8R)
+	fn(map[uint64]uint16(nil), (*Encoder).fastpathEncMapUint64Uint16R, (*Decoder).fastpathDecMapUint64Uint16R)
+	fn(map[uint64]uint32(nil), (*Encoder).fastpathEncMapUint64Uint32R, (*Decoder).fastpathDecMapUint64Uint32R)
+	fn(map[uint64]uint64(nil), (*Encoder).fastpathEncMapUint64Uint64R, (*Decoder).fastpathDecMapUint64Uint64R)
+	fn(map[uint64]uintptr(nil), (*Encoder).fastpathEncMapUint64UintptrR, (*Decoder).fastpathDecMapUint64UintptrR)
+	fn(map[uint64]int(nil), (*Encoder).fastpathEncMapUint64IntR, (*Decoder).fastpathDecMapUint64IntR)
+	fn(map[uint64]int8(nil), (*Encoder).fastpathEncMapUint64Int8R, (*Decoder).fastpathDecMapUint64Int8R)
+	fn(map[uint64]int16(nil), (*Encoder).fastpathEncMapUint64Int16R, (*Decoder).fastpathDecMapUint64Int16R)
+	fn(map[uint64]int32(nil), (*Encoder).fastpathEncMapUint64Int32R, (*Decoder).fastpathDecMapUint64Int32R)
+	fn(map[uint64]int64(nil), (*Encoder).fastpathEncMapUint64Int64R, (*Decoder).fastpathDecMapUint64Int64R)
+	fn(map[uint64]float32(nil), (*Encoder).fastpathEncMapUint64Float32R, (*Decoder).fastpathDecMapUint64Float32R)
+	fn(map[uint64]float64(nil), (*Encoder).fastpathEncMapUint64Float64R, (*Decoder).fastpathDecMapUint64Float64R)
+	fn(map[uint64]bool(nil), (*Encoder).fastpathEncMapUint64BoolR, (*Decoder).fastpathDecMapUint64BoolR)
+	fn(map[uintptr]interface{}(nil), (*Encoder).fastpathEncMapUintptrIntfR, (*Decoder).fastpathDecMapUintptrIntfR)
+	fn(map[uintptr]string(nil), (*Encoder).fastpathEncMapUintptrStringR, (*Decoder).fastpathDecMapUintptrStringR)
+	fn(map[uintptr]uint(nil), (*Encoder).fastpathEncMapUintptrUintR, (*Decoder).fastpathDecMapUintptrUintR)
+	fn(map[uintptr]uint8(nil), (*Encoder).fastpathEncMapUintptrUint8R, (*Decoder).fastpathDecMapUintptrUint8R)
+	fn(map[uintptr]uint16(nil), (*Encoder).fastpathEncMapUintptrUint16R, (*Decoder).fastpathDecMapUintptrUint16R)
+	fn(map[uintptr]uint32(nil), (*Encoder).fastpathEncMapUintptrUint32R, (*Decoder).fastpathDecMapUintptrUint32R)
+	fn(map[uintptr]uint64(nil), (*Encoder).fastpathEncMapUintptrUint64R, (*Decoder).fastpathDecMapUintptrUint64R)
+	fn(map[uintptr]uintptr(nil), (*Encoder).fastpathEncMapUintptrUintptrR, (*Decoder).fastpathDecMapUintptrUintptrR)
+	fn(map[uintptr]int(nil), (*Encoder).fastpathEncMapUintptrIntR, (*Decoder).fastpathDecMapUintptrIntR)
+	fn(map[uintptr]int8(nil), (*Encoder).fastpathEncMapUintptrInt8R, (*Decoder).fastpathDecMapUintptrInt8R)
+	fn(map[uintptr]int16(nil), (*Encoder).fastpathEncMapUintptrInt16R, (*Decoder).fastpathDecMapUintptrInt16R)
+	fn(map[uintptr]int32(nil), (*Encoder).fastpathEncMapUintptrInt32R, (*Decoder).fastpathDecMapUintptrInt32R)
+	fn(map[uintptr]int64(nil), (*Encoder).fastpathEncMapUintptrInt64R, (*Decoder).fastpathDecMapUintptrInt64R)
+	fn(map[uintptr]float32(nil), (*Encoder).fastpathEncMapUintptrFloat32R, (*Decoder).fastpathDecMapUintptrFloat32R)
+	fn(map[uintptr]float64(nil), (*Encoder).fastpathEncMapUintptrFloat64R, (*Decoder).fastpathDecMapUintptrFloat64R)
+	fn(map[uintptr]bool(nil), (*Encoder).fastpathEncMapUintptrBoolR, (*Decoder).fastpathDecMapUintptrBoolR)
+	fn(map[int]interface{}(nil), (*Encoder).fastpathEncMapIntIntfR, (*Decoder).fastpathDecMapIntIntfR)
+	fn(map[int]string(nil), (*Encoder).fastpathEncMapIntStringR, (*Decoder).fastpathDecMapIntStringR)
+	fn(map[int]uint(nil), (*Encoder).fastpathEncMapIntUintR, (*Decoder).fastpathDecMapIntUintR)
+	fn(map[int]uint8(nil), (*Encoder).fastpathEncMapIntUint8R, (*Decoder).fastpathDecMapIntUint8R)
+	fn(map[int]uint16(nil), (*Encoder).fastpathEncMapIntUint16R, (*Decoder).fastpathDecMapIntUint16R)
+	fn(map[int]uint32(nil), (*Encoder).fastpathEncMapIntUint32R, (*Decoder).fastpathDecMapIntUint32R)
+	fn(map[int]uint64(nil), (*Encoder).fastpathEncMapIntUint64R, (*Decoder).fastpathDecMapIntUint64R)
+	fn(map[int]uintptr(nil), (*Encoder).fastpathEncMapIntUintptrR, (*Decoder).fastpathDecMapIntUintptrR)
+	fn(map[int]int(nil), (*Encoder).fastpathEncMapIntIntR, (*Decoder).fastpathDecMapIntIntR)
+	fn(map[int]int8(nil), (*Encoder).fastpathEncMapIntInt8R, (*Decoder).fastpathDecMapIntInt8R)
+	fn(map[int]int16(nil), (*Encoder).fastpathEncMapIntInt16R, (*Decoder).fastpathDecMapIntInt16R)
+	fn(map[int]int32(nil), (*Encoder).fastpathEncMapIntInt32R, (*Decoder).fastpathDecMapIntInt32R)
+	fn(map[int]int64(nil), (*Encoder).fastpathEncMapIntInt64R, (*Decoder).fastpathDecMapIntInt64R)
+	fn(map[int]float32(nil), (*Encoder).fastpathEncMapIntFloat32R, (*Decoder).fastpathDecMapIntFloat32R)
+	fn(map[int]float64(nil), (*Encoder).fastpathEncMapIntFloat64R, (*Decoder).fastpathDecMapIntFloat64R)
+	fn(map[int]bool(nil), (*Encoder).fastpathEncMapIntBoolR, (*Decoder).fastpathDecMapIntBoolR)
+	fn(map[int8]interface{}(nil), (*Encoder).fastpathEncMapInt8IntfR, (*Decoder).fastpathDecMapInt8IntfR)
+	fn(map[int8]string(nil), (*Encoder).fastpathEncMapInt8StringR, (*Decoder).fastpathDecMapInt8StringR)
+	fn(map[int8]uint(nil), (*Encoder).fastpathEncMapInt8UintR, (*Decoder).fastpathDecMapInt8UintR)
+	fn(map[int8]uint8(nil), (*Encoder).fastpathEncMapInt8Uint8R, (*Decoder).fastpathDecMapInt8Uint8R)
+	fn(map[int8]uint16(nil), (*Encoder).fastpathEncMapInt8Uint16R, (*Decoder).fastpathDecMapInt8Uint16R)
+	fn(map[int8]uint32(nil), (*Encoder).fastpathEncMapInt8Uint32R, (*Decoder).fastpathDecMapInt8Uint32R)
+	fn(map[int8]uint64(nil), (*Encoder).fastpathEncMapInt8Uint64R, (*Decoder).fastpathDecMapInt8Uint64R)
+	fn(map[int8]uintptr(nil), (*Encoder).fastpathEncMapInt8UintptrR, (*Decoder).fastpathDecMapInt8UintptrR)
+	fn(map[int8]int(nil), (*Encoder).fastpathEncMapInt8IntR, (*Decoder).fastpathDecMapInt8IntR)
+	fn(map[int8]int8(nil), (*Encoder).fastpathEncMapInt8Int8R, (*Decoder).fastpathDecMapInt8Int8R)
+	fn(map[int8]int16(nil), (*Encoder).fastpathEncMapInt8Int16R, (*Decoder).fastpathDecMapInt8Int16R)
+	fn(map[int8]int32(nil), (*Encoder).fastpathEncMapInt8Int32R, (*Decoder).fastpathDecMapInt8Int32R)
+	fn(map[int8]int64(nil), (*Encoder).fastpathEncMapInt8Int64R, (*Decoder).fastpathDecMapInt8Int64R)
+	fn(map[int8]float32(nil), (*Encoder).fastpathEncMapInt8Float32R, (*Decoder).fastpathDecMapInt8Float32R)
+	fn(map[int8]float64(nil), (*Encoder).fastpathEncMapInt8Float64R, (*Decoder).fastpathDecMapInt8Float64R)
+	fn(map[int8]bool(nil), (*Encoder).fastpathEncMapInt8BoolR, (*Decoder).fastpathDecMapInt8BoolR)
+	fn(map[int16]interface{}(nil), (*Encoder).fastpathEncMapInt16IntfR, (*Decoder).fastpathDecMapInt16IntfR)
+	fn(map[int16]string(nil), (*Encoder).fastpathEncMapInt16StringR, (*Decoder).fastpathDecMapInt16StringR)
+	fn(map[int16]uint(nil), (*Encoder).fastpathEncMapInt16UintR, (*Decoder).fastpathDecMapInt16UintR)
+	fn(map[int16]uint8(nil), (*Encoder).fastpathEncMapInt16Uint8R, (*Decoder).fastpathDecMapInt16Uint8R)
+	fn(map[int16]uint16(nil), (*Encoder).fastpathEncMapInt16Uint16R, (*Decoder).fastpathDecMapInt16Uint16R)
+	fn(map[int16]uint32(nil), (*Encoder).fastpathEncMapInt16Uint32R, (*Decoder).fastpathDecMapInt16Uint32R)
+	fn(map[int16]uint64(nil), (*Encoder).fastpathEncMapInt16Uint64R, (*Decoder).fastpathDecMapInt16Uint64R)
+	fn(map[int16]uintptr(nil), (*Encoder).fastpathEncMapInt16UintptrR, (*Decoder).fastpathDecMapInt16UintptrR)
+	fn(map[int16]int(nil), (*Encoder).fastpathEncMapInt16IntR, (*Decoder).fastpathDecMapInt16IntR)
+	fn(map[int16]int8(nil), (*Encoder).fastpathEncMapInt16Int8R, (*Decoder).fastpathDecMapInt16Int8R)
+	fn(map[int16]int16(nil), (*Encoder).fastpathEncMapInt16Int16R, (*Decoder).fastpathDecMapInt16Int16R)
+	fn(map[int16]int32(nil), (*Encoder).fastpathEncMapInt16Int32R, (*Decoder).fastpathDecMapInt16Int32R)
+	fn(map[int16]int64(nil), (*Encoder).fastpathEncMapInt16Int64R, (*Decoder).fastpathDecMapInt16Int64R)
+	fn(map[int16]float32(nil), (*Encoder).fastpathEncMapInt16Float32R, (*Decoder).fastpathDecMapInt16Float32R)
+	fn(map[int16]float64(nil), (*Encoder).fastpathEncMapInt16Float64R, (*Decoder).fastpathDecMapInt16Float64R)
+	fn(map[int16]bool(nil), (*Encoder).fastpathEncMapInt16BoolR, (*Decoder).fastpathDecMapInt16BoolR)
+	fn(map[int32]interface{}(nil), (*Encoder).fastpathEncMapInt32IntfR, (*Decoder).fastpathDecMapInt32IntfR)
+	fn(map[int32]string(nil), (*Encoder).fastpathEncMapInt32StringR, (*Decoder).fastpathDecMapInt32StringR)
+	fn(map[int32]uint(nil), (*Encoder).fastpathEncMapInt32UintR, (*Decoder).fastpathDecMapInt32UintR)
+	fn(map[int32]uint8(nil), (*Encoder).fastpathEncMapInt32Uint8R, (*Decoder).fastpathDecMapInt32Uint8R)
+	fn(map[int32]uint16(nil), (*Encoder).fastpathEncMapInt32Uint16R, (*Decoder).fastpathDecMapInt32Uint16R)
+	fn(map[int32]uint32(nil), (*Encoder).fastpathEncMapInt32Uint32R, (*Decoder).fastpathDecMapInt32Uint32R)
+	fn(map[int32]uint64(nil), (*Encoder).fastpathEncMapInt32Uint64R, (*Decoder).fastpathDecMapInt32Uint64R)
+	fn(map[int32]uintptr(nil), (*Encoder).fastpathEncMapInt32UintptrR, (*Decoder).fastpathDecMapInt32UintptrR)
+	fn(map[int32]int(nil), (*Encoder).fastpathEncMapInt32IntR, (*Decoder).fastpathDecMapInt32IntR)
+	fn(map[int32]int8(nil), (*Encoder).fastpathEncMapInt32Int8R, (*Decoder).fastpathDecMapInt32Int8R)
+	fn(map[int32]int16(nil), (*Encoder).fastpathEncMapInt32Int16R, (*Decoder).fastpathDecMapInt32Int16R)
+	fn(map[int32]int32(nil), (*Encoder).fastpathEncMapInt32Int32R, (*Decoder).fastpathDecMapInt32Int32R)
+	fn(map[int32]int64(nil), (*Encoder).fastpathEncMapInt32Int64R, (*Decoder).fastpathDecMapInt32Int64R)
+	fn(map[int32]float32(nil), (*Encoder).fastpathEncMapInt32Float32R, (*Decoder).fastpathDecMapInt32Float32R)
+	fn(map[int32]float64(nil), (*Encoder).fastpathEncMapInt32Float64R, (*Decoder).fastpathDecMapInt32Float64R)
+	fn(map[int32]bool(nil), (*Encoder).fastpathEncMapInt32BoolR, (*Decoder).fastpathDecMapInt32BoolR)
+	fn(map[int64]interface{}(nil), (*Encoder).fastpathEncMapInt64IntfR, (*Decoder).fastpathDecMapInt64IntfR)
+	fn(map[int64]string(nil), (*Encoder).fastpathEncMapInt64StringR, (*Decoder).fastpathDecMapInt64StringR)
+	fn(map[int64]uint(nil), (*Encoder).fastpathEncMapInt64UintR, (*Decoder).fastpathDecMapInt64UintR)
+	fn(map[int64]uint8(nil), (*Encoder).fastpathEncMapInt64Uint8R, (*Decoder).fastpathDecMapInt64Uint8R)
+	fn(map[int64]uint16(nil), (*Encoder).fastpathEncMapInt64Uint16R, (*Decoder).fastpathDecMapInt64Uint16R)
+	fn(map[int64]uint32(nil), (*Encoder).fastpathEncMapInt64Uint32R, (*Decoder).fastpathDecMapInt64Uint32R)
+	fn(map[int64]uint64(nil), (*Encoder).fastpathEncMapInt64Uint64R, (*Decoder).fastpathDecMapInt64Uint64R)
+	fn(map[int64]uintptr(nil), (*Encoder).fastpathEncMapInt64UintptrR, (*Decoder).fastpathDecMapInt64UintptrR)
+	fn(map[int64]int(nil), (*Encoder).fastpathEncMapInt64IntR, (*Decoder).fastpathDecMapInt64IntR)
+	fn(map[int64]int8(nil), (*Encoder).fastpathEncMapInt64Int8R, (*Decoder).fastpathDecMapInt64Int8R)
+	fn(map[int64]int16(nil), (*Encoder).fastpathEncMapInt64Int16R, (*Decoder).fastpathDecMapInt64Int16R)
+	fn(map[int64]int32(nil), (*Encoder).fastpathEncMapInt64Int32R, (*Decoder).fastpathDecMapInt64Int32R)
+	fn(map[int64]int64(nil), (*Encoder).fastpathEncMapInt64Int64R, (*Decoder).fastpathDecMapInt64Int64R)
+	fn(map[int64]float32(nil), (*Encoder).fastpathEncMapInt64Float32R, (*Decoder).fastpathDecMapInt64Float32R)
+	fn(map[int64]float64(nil), (*Encoder).fastpathEncMapInt64Float64R, (*Decoder).fastpathDecMapInt64Float64R)
+	fn(map[int64]bool(nil), (*Encoder).fastpathEncMapInt64BoolR, (*Decoder).fastpathDecMapInt64BoolR)
+	fn(map[bool]interface{}(nil), (*Encoder).fastpathEncMapBoolIntfR, (*Decoder).fastpathDecMapBoolIntfR)
+	fn(map[bool]string(nil), (*Encoder).fastpathEncMapBoolStringR, (*Decoder).fastpathDecMapBoolStringR)
+	fn(map[bool]uint(nil), (*Encoder).fastpathEncMapBoolUintR, (*Decoder).fastpathDecMapBoolUintR)
+	fn(map[bool]uint8(nil), (*Encoder).fastpathEncMapBoolUint8R, (*Decoder).fastpathDecMapBoolUint8R)
+	fn(map[bool]uint16(nil), (*Encoder).fastpathEncMapBoolUint16R, (*Decoder).fastpathDecMapBoolUint16R)
+	fn(map[bool]uint32(nil), (*Encoder).fastpathEncMapBoolUint32R, (*Decoder).fastpathDecMapBoolUint32R)
+	fn(map[bool]uint64(nil), (*Encoder).fastpathEncMapBoolUint64R, (*Decoder).fastpathDecMapBoolUint64R)
+	fn(map[bool]uintptr(nil), (*Encoder).fastpathEncMapBoolUintptrR, (*Decoder).fastpathDecMapBoolUintptrR)
+	fn(map[bool]int(nil), (*Encoder).fastpathEncMapBoolIntR, (*Decoder).fastpathDecMapBoolIntR)
+	fn(map[bool]int8(nil), (*Encoder).fastpathEncMapBoolInt8R, (*Decoder).fastpathDecMapBoolInt8R)
+	fn(map[bool]int16(nil), (*Encoder).fastpathEncMapBoolInt16R, (*Decoder).fastpathDecMapBoolInt16R)
+	fn(map[bool]int32(nil), (*Encoder).fastpathEncMapBoolInt32R, (*Decoder).fastpathDecMapBoolInt32R)
+	fn(map[bool]int64(nil), (*Encoder).fastpathEncMapBoolInt64R, (*Decoder).fastpathDecMapBoolInt64R)
+	fn(map[bool]float32(nil), (*Encoder).fastpathEncMapBoolFloat32R, (*Decoder).fastpathDecMapBoolFloat32R)
+	fn(map[bool]float64(nil), (*Encoder).fastpathEncMapBoolFloat64R, (*Decoder).fastpathDecMapBoolFloat64R)
+	fn(map[bool]bool(nil), (*Encoder).fastpathEncMapBoolBoolR, (*Decoder).fastpathDecMapBoolBoolR)
 
 	sort.Sort(fastpathAslice(fastpathAV[:]))
 }
@@ -375,1359 +378,1359 @@ func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
 	switch v := iv.(type) {
 
 	case []interface{}:
-		fastpathTV.EncSliceIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceIntfV(v, e)
 	case *[]interface{}:
-		fastpathTV.EncSliceIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceIntfV(*v, e)
 
 	case map[interface{}]interface{}:
-		fastpathTV.EncMapIntfIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfIntfV(v, e)
 	case *map[interface{}]interface{}:
-		fastpathTV.EncMapIntfIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfIntfV(*v, e)
 
 	case map[interface{}]string:
-		fastpathTV.EncMapIntfStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfStringV(v, e)
 	case *map[interface{}]string:
-		fastpathTV.EncMapIntfStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfStringV(*v, e)
 
 	case map[interface{}]uint:
-		fastpathTV.EncMapIntfUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUintV(v, e)
 	case *map[interface{}]uint:
-		fastpathTV.EncMapIntfUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUintV(*v, e)
 
 	case map[interface{}]uint8:
-		fastpathTV.EncMapIntfUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint8V(v, e)
 	case *map[interface{}]uint8:
-		fastpathTV.EncMapIntfUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint8V(*v, e)
 
 	case map[interface{}]uint16:
-		fastpathTV.EncMapIntfUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint16V(v, e)
 	case *map[interface{}]uint16:
-		fastpathTV.EncMapIntfUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint16V(*v, e)
 
 	case map[interface{}]uint32:
-		fastpathTV.EncMapIntfUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint32V(v, e)
 	case *map[interface{}]uint32:
-		fastpathTV.EncMapIntfUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint32V(*v, e)
 
 	case map[interface{}]uint64:
-		fastpathTV.EncMapIntfUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint64V(v, e)
 	case *map[interface{}]uint64:
-		fastpathTV.EncMapIntfUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint64V(*v, e)
 
 	case map[interface{}]uintptr:
-		fastpathTV.EncMapIntfUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUintptrV(v, e)
 	case *map[interface{}]uintptr:
-		fastpathTV.EncMapIntfUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUintptrV(*v, e)
 
 	case map[interface{}]int:
-		fastpathTV.EncMapIntfIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfIntV(v, e)
 	case *map[interface{}]int:
-		fastpathTV.EncMapIntfIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfIntV(*v, e)
 
 	case map[interface{}]int8:
-		fastpathTV.EncMapIntfInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt8V(v, e)
 	case *map[interface{}]int8:
-		fastpathTV.EncMapIntfInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt8V(*v, e)
 
 	case map[interface{}]int16:
-		fastpathTV.EncMapIntfInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt16V(v, e)
 	case *map[interface{}]int16:
-		fastpathTV.EncMapIntfInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt16V(*v, e)
 
 	case map[interface{}]int32:
-		fastpathTV.EncMapIntfInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt32V(v, e)
 	case *map[interface{}]int32:
-		fastpathTV.EncMapIntfInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt32V(*v, e)
 
 	case map[interface{}]int64:
-		fastpathTV.EncMapIntfInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt64V(v, e)
 	case *map[interface{}]int64:
-		fastpathTV.EncMapIntfInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt64V(*v, e)
 
 	case map[interface{}]float32:
-		fastpathTV.EncMapIntfFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfFloat32V(v, e)
 	case *map[interface{}]float32:
-		fastpathTV.EncMapIntfFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfFloat32V(*v, e)
 
 	case map[interface{}]float64:
-		fastpathTV.EncMapIntfFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfFloat64V(v, e)
 	case *map[interface{}]float64:
-		fastpathTV.EncMapIntfFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfFloat64V(*v, e)
 
 	case map[interface{}]bool:
-		fastpathTV.EncMapIntfBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfBoolV(v, e)
 	case *map[interface{}]bool:
-		fastpathTV.EncMapIntfBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfBoolV(*v, e)
 
 	case []string:
-		fastpathTV.EncSliceStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceStringV(v, e)
 	case *[]string:
-		fastpathTV.EncSliceStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceStringV(*v, e)
 
 	case map[string]interface{}:
-		fastpathTV.EncMapStringIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringIntfV(v, e)
 	case *map[string]interface{}:
-		fastpathTV.EncMapStringIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringIntfV(*v, e)
 
 	case map[string]string:
-		fastpathTV.EncMapStringStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringStringV(v, e)
 	case *map[string]string:
-		fastpathTV.EncMapStringStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringStringV(*v, e)
 
 	case map[string]uint:
-		fastpathTV.EncMapStringUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUintV(v, e)
 	case *map[string]uint:
-		fastpathTV.EncMapStringUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUintV(*v, e)
 
 	case map[string]uint8:
-		fastpathTV.EncMapStringUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint8V(v, e)
 	case *map[string]uint8:
-		fastpathTV.EncMapStringUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint8V(*v, e)
 
 	case map[string]uint16:
-		fastpathTV.EncMapStringUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint16V(v, e)
 	case *map[string]uint16:
-		fastpathTV.EncMapStringUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint16V(*v, e)
 
 	case map[string]uint32:
-		fastpathTV.EncMapStringUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint32V(v, e)
 	case *map[string]uint32:
-		fastpathTV.EncMapStringUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint32V(*v, e)
 
 	case map[string]uint64:
-		fastpathTV.EncMapStringUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint64V(v, e)
 	case *map[string]uint64:
-		fastpathTV.EncMapStringUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint64V(*v, e)
 
 	case map[string]uintptr:
-		fastpathTV.EncMapStringUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUintptrV(v, e)
 	case *map[string]uintptr:
-		fastpathTV.EncMapStringUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUintptrV(*v, e)
 
 	case map[string]int:
-		fastpathTV.EncMapStringIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringIntV(v, e)
 	case *map[string]int:
-		fastpathTV.EncMapStringIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringIntV(*v, e)
 
 	case map[string]int8:
-		fastpathTV.EncMapStringInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt8V(v, e)
 	case *map[string]int8:
-		fastpathTV.EncMapStringInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt8V(*v, e)
 
 	case map[string]int16:
-		fastpathTV.EncMapStringInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt16V(v, e)
 	case *map[string]int16:
-		fastpathTV.EncMapStringInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt16V(*v, e)
 
 	case map[string]int32:
-		fastpathTV.EncMapStringInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt32V(v, e)
 	case *map[string]int32:
-		fastpathTV.EncMapStringInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt32V(*v, e)
 
 	case map[string]int64:
-		fastpathTV.EncMapStringInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt64V(v, e)
 	case *map[string]int64:
-		fastpathTV.EncMapStringInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt64V(*v, e)
 
 	case map[string]float32:
-		fastpathTV.EncMapStringFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringFloat32V(v, e)
 	case *map[string]float32:
-		fastpathTV.EncMapStringFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringFloat32V(*v, e)
 
 	case map[string]float64:
-		fastpathTV.EncMapStringFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringFloat64V(v, e)
 	case *map[string]float64:
-		fastpathTV.EncMapStringFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringFloat64V(*v, e)
 
 	case map[string]bool:
-		fastpathTV.EncMapStringBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringBoolV(v, e)
 	case *map[string]bool:
-		fastpathTV.EncMapStringBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringBoolV(*v, e)
 
 	case []float32:
-		fastpathTV.EncSliceFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceFloat32V(v, e)
 	case *[]float32:
-		fastpathTV.EncSliceFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceFloat32V(*v, e)
 
 	case map[float32]interface{}:
-		fastpathTV.EncMapFloat32IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32IntfV(v, e)
 	case *map[float32]interface{}:
-		fastpathTV.EncMapFloat32IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32IntfV(*v, e)
 
 	case map[float32]string:
-		fastpathTV.EncMapFloat32StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32StringV(v, e)
 	case *map[float32]string:
-		fastpathTV.EncMapFloat32StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32StringV(*v, e)
 
 	case map[float32]uint:
-		fastpathTV.EncMapFloat32UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32UintV(v, e)
 	case *map[float32]uint:
-		fastpathTV.EncMapFloat32UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32UintV(*v, e)
 
 	case map[float32]uint8:
-		fastpathTV.EncMapFloat32Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint8V(v, e)
 	case *map[float32]uint8:
-		fastpathTV.EncMapFloat32Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint8V(*v, e)
 
 	case map[float32]uint16:
-		fastpathTV.EncMapFloat32Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint16V(v, e)
 	case *map[float32]uint16:
-		fastpathTV.EncMapFloat32Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint16V(*v, e)
 
 	case map[float32]uint32:
-		fastpathTV.EncMapFloat32Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint32V(v, e)
 	case *map[float32]uint32:
-		fastpathTV.EncMapFloat32Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint32V(*v, e)
 
 	case map[float32]uint64:
-		fastpathTV.EncMapFloat32Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint64V(v, e)
 	case *map[float32]uint64:
-		fastpathTV.EncMapFloat32Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint64V(*v, e)
 
 	case map[float32]uintptr:
-		fastpathTV.EncMapFloat32UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32UintptrV(v, e)
 	case *map[float32]uintptr:
-		fastpathTV.EncMapFloat32UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32UintptrV(*v, e)
 
 	case map[float32]int:
-		fastpathTV.EncMapFloat32IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32IntV(v, e)
 	case *map[float32]int:
-		fastpathTV.EncMapFloat32IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32IntV(*v, e)
 
 	case map[float32]int8:
-		fastpathTV.EncMapFloat32Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int8V(v, e)
 	case *map[float32]int8:
-		fastpathTV.EncMapFloat32Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int8V(*v, e)
 
 	case map[float32]int16:
-		fastpathTV.EncMapFloat32Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int16V(v, e)
 	case *map[float32]int16:
-		fastpathTV.EncMapFloat32Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int16V(*v, e)
 
 	case map[float32]int32:
-		fastpathTV.EncMapFloat32Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int32V(v, e)
 	case *map[float32]int32:
-		fastpathTV.EncMapFloat32Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int32V(*v, e)
 
 	case map[float32]int64:
-		fastpathTV.EncMapFloat32Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int64V(v, e)
 	case *map[float32]int64:
-		fastpathTV.EncMapFloat32Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int64V(*v, e)
 
 	case map[float32]float32:
-		fastpathTV.EncMapFloat32Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Float32V(v, e)
 	case *map[float32]float32:
-		fastpathTV.EncMapFloat32Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Float32V(*v, e)
 
 	case map[float32]float64:
-		fastpathTV.EncMapFloat32Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Float64V(v, e)
 	case *map[float32]float64:
-		fastpathTV.EncMapFloat32Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Float64V(*v, e)
 
 	case map[float32]bool:
-		fastpathTV.EncMapFloat32BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32BoolV(v, e)
 	case *map[float32]bool:
-		fastpathTV.EncMapFloat32BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32BoolV(*v, e)
 
 	case []float64:
-		fastpathTV.EncSliceFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceFloat64V(v, e)
 	case *[]float64:
-		fastpathTV.EncSliceFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceFloat64V(*v, e)
 
 	case map[float64]interface{}:
-		fastpathTV.EncMapFloat64IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64IntfV(v, e)
 	case *map[float64]interface{}:
-		fastpathTV.EncMapFloat64IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64IntfV(*v, e)
 
 	case map[float64]string:
-		fastpathTV.EncMapFloat64StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64StringV(v, e)
 	case *map[float64]string:
-		fastpathTV.EncMapFloat64StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64StringV(*v, e)
 
 	case map[float64]uint:
-		fastpathTV.EncMapFloat64UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64UintV(v, e)
 	case *map[float64]uint:
-		fastpathTV.EncMapFloat64UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64UintV(*v, e)
 
 	case map[float64]uint8:
-		fastpathTV.EncMapFloat64Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint8V(v, e)
 	case *map[float64]uint8:
-		fastpathTV.EncMapFloat64Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint8V(*v, e)
 
 	case map[float64]uint16:
-		fastpathTV.EncMapFloat64Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint16V(v, e)
 	case *map[float64]uint16:
-		fastpathTV.EncMapFloat64Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint16V(*v, e)
 
 	case map[float64]uint32:
-		fastpathTV.EncMapFloat64Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint32V(v, e)
 	case *map[float64]uint32:
-		fastpathTV.EncMapFloat64Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint32V(*v, e)
 
 	case map[float64]uint64:
-		fastpathTV.EncMapFloat64Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint64V(v, e)
 	case *map[float64]uint64:
-		fastpathTV.EncMapFloat64Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint64V(*v, e)
 
 	case map[float64]uintptr:
-		fastpathTV.EncMapFloat64UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64UintptrV(v, e)
 	case *map[float64]uintptr:
-		fastpathTV.EncMapFloat64UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64UintptrV(*v, e)
 
 	case map[float64]int:
-		fastpathTV.EncMapFloat64IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64IntV(v, e)
 	case *map[float64]int:
-		fastpathTV.EncMapFloat64IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64IntV(*v, e)
 
 	case map[float64]int8:
-		fastpathTV.EncMapFloat64Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int8V(v, e)
 	case *map[float64]int8:
-		fastpathTV.EncMapFloat64Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int8V(*v, e)
 
 	case map[float64]int16:
-		fastpathTV.EncMapFloat64Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int16V(v, e)
 	case *map[float64]int16:
-		fastpathTV.EncMapFloat64Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int16V(*v, e)
 
 	case map[float64]int32:
-		fastpathTV.EncMapFloat64Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int32V(v, e)
 	case *map[float64]int32:
-		fastpathTV.EncMapFloat64Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int32V(*v, e)
 
 	case map[float64]int64:
-		fastpathTV.EncMapFloat64Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int64V(v, e)
 	case *map[float64]int64:
-		fastpathTV.EncMapFloat64Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int64V(*v, e)
 
 	case map[float64]float32:
-		fastpathTV.EncMapFloat64Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Float32V(v, e)
 	case *map[float64]float32:
-		fastpathTV.EncMapFloat64Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Float32V(*v, e)
 
 	case map[float64]float64:
-		fastpathTV.EncMapFloat64Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Float64V(v, e)
 	case *map[float64]float64:
-		fastpathTV.EncMapFloat64Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Float64V(*v, e)
 
 	case map[float64]bool:
-		fastpathTV.EncMapFloat64BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64BoolV(v, e)
 	case *map[float64]bool:
-		fastpathTV.EncMapFloat64BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64BoolV(*v, e)
 
 	case []uint:
-		fastpathTV.EncSliceUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUintV(v, e)
 	case *[]uint:
-		fastpathTV.EncSliceUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUintV(*v, e)
 
 	case map[uint]interface{}:
-		fastpathTV.EncMapUintIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintIntfV(v, e)
 	case *map[uint]interface{}:
-		fastpathTV.EncMapUintIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintIntfV(*v, e)
 
 	case map[uint]string:
-		fastpathTV.EncMapUintStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintStringV(v, e)
 	case *map[uint]string:
-		fastpathTV.EncMapUintStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintStringV(*v, e)
 
 	case map[uint]uint:
-		fastpathTV.EncMapUintUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUintV(v, e)
 	case *map[uint]uint:
-		fastpathTV.EncMapUintUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUintV(*v, e)
 
 	case map[uint]uint8:
-		fastpathTV.EncMapUintUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint8V(v, e)
 	case *map[uint]uint8:
-		fastpathTV.EncMapUintUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint8V(*v, e)
 
 	case map[uint]uint16:
-		fastpathTV.EncMapUintUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint16V(v, e)
 	case *map[uint]uint16:
-		fastpathTV.EncMapUintUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint16V(*v, e)
 
 	case map[uint]uint32:
-		fastpathTV.EncMapUintUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint32V(v, e)
 	case *map[uint]uint32:
-		fastpathTV.EncMapUintUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint32V(*v, e)
 
 	case map[uint]uint64:
-		fastpathTV.EncMapUintUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint64V(v, e)
 	case *map[uint]uint64:
-		fastpathTV.EncMapUintUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint64V(*v, e)
 
 	case map[uint]uintptr:
-		fastpathTV.EncMapUintUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUintptrV(v, e)
 	case *map[uint]uintptr:
-		fastpathTV.EncMapUintUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUintptrV(*v, e)
 
 	case map[uint]int:
-		fastpathTV.EncMapUintIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintIntV(v, e)
 	case *map[uint]int:
-		fastpathTV.EncMapUintIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintIntV(*v, e)
 
 	case map[uint]int8:
-		fastpathTV.EncMapUintInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt8V(v, e)
 	case *map[uint]int8:
-		fastpathTV.EncMapUintInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt8V(*v, e)
 
 	case map[uint]int16:
-		fastpathTV.EncMapUintInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt16V(v, e)
 	case *map[uint]int16:
-		fastpathTV.EncMapUintInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt16V(*v, e)
 
 	case map[uint]int32:
-		fastpathTV.EncMapUintInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt32V(v, e)
 	case *map[uint]int32:
-		fastpathTV.EncMapUintInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt32V(*v, e)
 
 	case map[uint]int64:
-		fastpathTV.EncMapUintInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt64V(v, e)
 	case *map[uint]int64:
-		fastpathTV.EncMapUintInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt64V(*v, e)
 
 	case map[uint]float32:
-		fastpathTV.EncMapUintFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintFloat32V(v, e)
 	case *map[uint]float32:
-		fastpathTV.EncMapUintFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintFloat32V(*v, e)
 
 	case map[uint]float64:
-		fastpathTV.EncMapUintFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintFloat64V(v, e)
 	case *map[uint]float64:
-		fastpathTV.EncMapUintFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintFloat64V(*v, e)
 
 	case map[uint]bool:
-		fastpathTV.EncMapUintBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintBoolV(v, e)
 	case *map[uint]bool:
-		fastpathTV.EncMapUintBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintBoolV(*v, e)
 
 	case map[uint8]interface{}:
-		fastpathTV.EncMapUint8IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8IntfV(v, e)
 	case *map[uint8]interface{}:
-		fastpathTV.EncMapUint8IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8IntfV(*v, e)
 
 	case map[uint8]string:
-		fastpathTV.EncMapUint8StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8StringV(v, e)
 	case *map[uint8]string:
-		fastpathTV.EncMapUint8StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8StringV(*v, e)
 
 	case map[uint8]uint:
-		fastpathTV.EncMapUint8UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8UintV(v, e)
 	case *map[uint8]uint:
-		fastpathTV.EncMapUint8UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8UintV(*v, e)
 
 	case map[uint8]uint8:
-		fastpathTV.EncMapUint8Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint8V(v, e)
 	case *map[uint8]uint8:
-		fastpathTV.EncMapUint8Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint8V(*v, e)
 
 	case map[uint8]uint16:
-		fastpathTV.EncMapUint8Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint16V(v, e)
 	case *map[uint8]uint16:
-		fastpathTV.EncMapUint8Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint16V(*v, e)
 
 	case map[uint8]uint32:
-		fastpathTV.EncMapUint8Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint32V(v, e)
 	case *map[uint8]uint32:
-		fastpathTV.EncMapUint8Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint32V(*v, e)
 
 	case map[uint8]uint64:
-		fastpathTV.EncMapUint8Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint64V(v, e)
 	case *map[uint8]uint64:
-		fastpathTV.EncMapUint8Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint64V(*v, e)
 
 	case map[uint8]uintptr:
-		fastpathTV.EncMapUint8UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8UintptrV(v, e)
 	case *map[uint8]uintptr:
-		fastpathTV.EncMapUint8UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8UintptrV(*v, e)
 
 	case map[uint8]int:
-		fastpathTV.EncMapUint8IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8IntV(v, e)
 	case *map[uint8]int:
-		fastpathTV.EncMapUint8IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8IntV(*v, e)
 
 	case map[uint8]int8:
-		fastpathTV.EncMapUint8Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int8V(v, e)
 	case *map[uint8]int8:
-		fastpathTV.EncMapUint8Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int8V(*v, e)
 
 	case map[uint8]int16:
-		fastpathTV.EncMapUint8Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int16V(v, e)
 	case *map[uint8]int16:
-		fastpathTV.EncMapUint8Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int16V(*v, e)
 
 	case map[uint8]int32:
-		fastpathTV.EncMapUint8Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int32V(v, e)
 	case *map[uint8]int32:
-		fastpathTV.EncMapUint8Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int32V(*v, e)
 
 	case map[uint8]int64:
-		fastpathTV.EncMapUint8Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int64V(v, e)
 	case *map[uint8]int64:
-		fastpathTV.EncMapUint8Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int64V(*v, e)
 
 	case map[uint8]float32:
-		fastpathTV.EncMapUint8Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Float32V(v, e)
 	case *map[uint8]float32:
-		fastpathTV.EncMapUint8Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Float32V(*v, e)
 
 	case map[uint8]float64:
-		fastpathTV.EncMapUint8Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Float64V(v, e)
 	case *map[uint8]float64:
-		fastpathTV.EncMapUint8Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Float64V(*v, e)
 
 	case map[uint8]bool:
-		fastpathTV.EncMapUint8BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8BoolV(v, e)
 	case *map[uint8]bool:
-		fastpathTV.EncMapUint8BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8BoolV(*v, e)
 
 	case []uint16:
-		fastpathTV.EncSliceUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint16V(v, e)
 	case *[]uint16:
-		fastpathTV.EncSliceUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint16V(*v, e)
 
 	case map[uint16]interface{}:
-		fastpathTV.EncMapUint16IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16IntfV(v, e)
 	case *map[uint16]interface{}:
-		fastpathTV.EncMapUint16IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16IntfV(*v, e)
 
 	case map[uint16]string:
-		fastpathTV.EncMapUint16StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16StringV(v, e)
 	case *map[uint16]string:
-		fastpathTV.EncMapUint16StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16StringV(*v, e)
 
 	case map[uint16]uint:
-		fastpathTV.EncMapUint16UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16UintV(v, e)
 	case *map[uint16]uint:
-		fastpathTV.EncMapUint16UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16UintV(*v, e)
 
 	case map[uint16]uint8:
-		fastpathTV.EncMapUint16Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint8V(v, e)
 	case *map[uint16]uint8:
-		fastpathTV.EncMapUint16Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint8V(*v, e)
 
 	case map[uint16]uint16:
-		fastpathTV.EncMapUint16Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint16V(v, e)
 	case *map[uint16]uint16:
-		fastpathTV.EncMapUint16Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint16V(*v, e)
 
 	case map[uint16]uint32:
-		fastpathTV.EncMapUint16Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint32V(v, e)
 	case *map[uint16]uint32:
-		fastpathTV.EncMapUint16Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint32V(*v, e)
 
 	case map[uint16]uint64:
-		fastpathTV.EncMapUint16Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint64V(v, e)
 	case *map[uint16]uint64:
-		fastpathTV.EncMapUint16Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint64V(*v, e)
 
 	case map[uint16]uintptr:
-		fastpathTV.EncMapUint16UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16UintptrV(v, e)
 	case *map[uint16]uintptr:
-		fastpathTV.EncMapUint16UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16UintptrV(*v, e)
 
 	case map[uint16]int:
-		fastpathTV.EncMapUint16IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16IntV(v, e)
 	case *map[uint16]int:
-		fastpathTV.EncMapUint16IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16IntV(*v, e)
 
 	case map[uint16]int8:
-		fastpathTV.EncMapUint16Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int8V(v, e)
 	case *map[uint16]int8:
-		fastpathTV.EncMapUint16Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int8V(*v, e)
 
 	case map[uint16]int16:
-		fastpathTV.EncMapUint16Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int16V(v, e)
 	case *map[uint16]int16:
-		fastpathTV.EncMapUint16Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int16V(*v, e)
 
 	case map[uint16]int32:
-		fastpathTV.EncMapUint16Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int32V(v, e)
 	case *map[uint16]int32:
-		fastpathTV.EncMapUint16Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int32V(*v, e)
 
 	case map[uint16]int64:
-		fastpathTV.EncMapUint16Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int64V(v, e)
 	case *map[uint16]int64:
-		fastpathTV.EncMapUint16Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int64V(*v, e)
 
 	case map[uint16]float32:
-		fastpathTV.EncMapUint16Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Float32V(v, e)
 	case *map[uint16]float32:
-		fastpathTV.EncMapUint16Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Float32V(*v, e)
 
 	case map[uint16]float64:
-		fastpathTV.EncMapUint16Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Float64V(v, e)
 	case *map[uint16]float64:
-		fastpathTV.EncMapUint16Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Float64V(*v, e)
 
 	case map[uint16]bool:
-		fastpathTV.EncMapUint16BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16BoolV(v, e)
 	case *map[uint16]bool:
-		fastpathTV.EncMapUint16BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16BoolV(*v, e)
 
 	case []uint32:
-		fastpathTV.EncSliceUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint32V(v, e)
 	case *[]uint32:
-		fastpathTV.EncSliceUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint32V(*v, e)
 
 	case map[uint32]interface{}:
-		fastpathTV.EncMapUint32IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32IntfV(v, e)
 	case *map[uint32]interface{}:
-		fastpathTV.EncMapUint32IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32IntfV(*v, e)
 
 	case map[uint32]string:
-		fastpathTV.EncMapUint32StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32StringV(v, e)
 	case *map[uint32]string:
-		fastpathTV.EncMapUint32StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32StringV(*v, e)
 
 	case map[uint32]uint:
-		fastpathTV.EncMapUint32UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32UintV(v, e)
 	case *map[uint32]uint:
-		fastpathTV.EncMapUint32UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32UintV(*v, e)
 
 	case map[uint32]uint8:
-		fastpathTV.EncMapUint32Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint8V(v, e)
 	case *map[uint32]uint8:
-		fastpathTV.EncMapUint32Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint8V(*v, e)
 
 	case map[uint32]uint16:
-		fastpathTV.EncMapUint32Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint16V(v, e)
 	case *map[uint32]uint16:
-		fastpathTV.EncMapUint32Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint16V(*v, e)
 
 	case map[uint32]uint32:
-		fastpathTV.EncMapUint32Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint32V(v, e)
 	case *map[uint32]uint32:
-		fastpathTV.EncMapUint32Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint32V(*v, e)
 
 	case map[uint32]uint64:
-		fastpathTV.EncMapUint32Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint64V(v, e)
 	case *map[uint32]uint64:
-		fastpathTV.EncMapUint32Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint64V(*v, e)
 
 	case map[uint32]uintptr:
-		fastpathTV.EncMapUint32UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32UintptrV(v, e)
 	case *map[uint32]uintptr:
-		fastpathTV.EncMapUint32UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32UintptrV(*v, e)
 
 	case map[uint32]int:
-		fastpathTV.EncMapUint32IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32IntV(v, e)
 	case *map[uint32]int:
-		fastpathTV.EncMapUint32IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32IntV(*v, e)
 
 	case map[uint32]int8:
-		fastpathTV.EncMapUint32Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int8V(v, e)
 	case *map[uint32]int8:
-		fastpathTV.EncMapUint32Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int8V(*v, e)
 
 	case map[uint32]int16:
-		fastpathTV.EncMapUint32Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int16V(v, e)
 	case *map[uint32]int16:
-		fastpathTV.EncMapUint32Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int16V(*v, e)
 
 	case map[uint32]int32:
-		fastpathTV.EncMapUint32Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int32V(v, e)
 	case *map[uint32]int32:
-		fastpathTV.EncMapUint32Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int32V(*v, e)
 
 	case map[uint32]int64:
-		fastpathTV.EncMapUint32Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int64V(v, e)
 	case *map[uint32]int64:
-		fastpathTV.EncMapUint32Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int64V(*v, e)
 
 	case map[uint32]float32:
-		fastpathTV.EncMapUint32Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Float32V(v, e)
 	case *map[uint32]float32:
-		fastpathTV.EncMapUint32Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Float32V(*v, e)
 
 	case map[uint32]float64:
-		fastpathTV.EncMapUint32Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Float64V(v, e)
 	case *map[uint32]float64:
-		fastpathTV.EncMapUint32Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Float64V(*v, e)
 
 	case map[uint32]bool:
-		fastpathTV.EncMapUint32BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32BoolV(v, e)
 	case *map[uint32]bool:
-		fastpathTV.EncMapUint32BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32BoolV(*v, e)
 
 	case []uint64:
-		fastpathTV.EncSliceUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint64V(v, e)
 	case *[]uint64:
-		fastpathTV.EncSliceUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint64V(*v, e)
 
 	case map[uint64]interface{}:
-		fastpathTV.EncMapUint64IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64IntfV(v, e)
 	case *map[uint64]interface{}:
-		fastpathTV.EncMapUint64IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64IntfV(*v, e)
 
 	case map[uint64]string:
-		fastpathTV.EncMapUint64StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64StringV(v, e)
 	case *map[uint64]string:
-		fastpathTV.EncMapUint64StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64StringV(*v, e)
 
 	case map[uint64]uint:
-		fastpathTV.EncMapUint64UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64UintV(v, e)
 	case *map[uint64]uint:
-		fastpathTV.EncMapUint64UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64UintV(*v, e)
 
 	case map[uint64]uint8:
-		fastpathTV.EncMapUint64Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint8V(v, e)
 	case *map[uint64]uint8:
-		fastpathTV.EncMapUint64Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint8V(*v, e)
 
 	case map[uint64]uint16:
-		fastpathTV.EncMapUint64Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint16V(v, e)
 	case *map[uint64]uint16:
-		fastpathTV.EncMapUint64Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint16V(*v, e)
 
 	case map[uint64]uint32:
-		fastpathTV.EncMapUint64Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint32V(v, e)
 	case *map[uint64]uint32:
-		fastpathTV.EncMapUint64Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint32V(*v, e)
 
 	case map[uint64]uint64:
-		fastpathTV.EncMapUint64Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint64V(v, e)
 	case *map[uint64]uint64:
-		fastpathTV.EncMapUint64Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint64V(*v, e)
 
 	case map[uint64]uintptr:
-		fastpathTV.EncMapUint64UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64UintptrV(v, e)
 	case *map[uint64]uintptr:
-		fastpathTV.EncMapUint64UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64UintptrV(*v, e)
 
 	case map[uint64]int:
-		fastpathTV.EncMapUint64IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64IntV(v, e)
 	case *map[uint64]int:
-		fastpathTV.EncMapUint64IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64IntV(*v, e)
 
 	case map[uint64]int8:
-		fastpathTV.EncMapUint64Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int8V(v, e)
 	case *map[uint64]int8:
-		fastpathTV.EncMapUint64Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int8V(*v, e)
 
 	case map[uint64]int16:
-		fastpathTV.EncMapUint64Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int16V(v, e)
 	case *map[uint64]int16:
-		fastpathTV.EncMapUint64Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int16V(*v, e)
 
 	case map[uint64]int32:
-		fastpathTV.EncMapUint64Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int32V(v, e)
 	case *map[uint64]int32:
-		fastpathTV.EncMapUint64Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int32V(*v, e)
 
 	case map[uint64]int64:
-		fastpathTV.EncMapUint64Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int64V(v, e)
 	case *map[uint64]int64:
-		fastpathTV.EncMapUint64Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int64V(*v, e)
 
 	case map[uint64]float32:
-		fastpathTV.EncMapUint64Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Float32V(v, e)
 	case *map[uint64]float32:
-		fastpathTV.EncMapUint64Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Float32V(*v, e)
 
 	case map[uint64]float64:
-		fastpathTV.EncMapUint64Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Float64V(v, e)
 	case *map[uint64]float64:
-		fastpathTV.EncMapUint64Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Float64V(*v, e)
 
 	case map[uint64]bool:
-		fastpathTV.EncMapUint64BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64BoolV(v, e)
 	case *map[uint64]bool:
-		fastpathTV.EncMapUint64BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64BoolV(*v, e)
 
 	case []uintptr:
-		fastpathTV.EncSliceUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUintptrV(v, e)
 	case *[]uintptr:
-		fastpathTV.EncSliceUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUintptrV(*v, e)
 
 	case map[uintptr]interface{}:
-		fastpathTV.EncMapUintptrIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrIntfV(v, e)
 	case *map[uintptr]interface{}:
-		fastpathTV.EncMapUintptrIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrIntfV(*v, e)
 
 	case map[uintptr]string:
-		fastpathTV.EncMapUintptrStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrStringV(v, e)
 	case *map[uintptr]string:
-		fastpathTV.EncMapUintptrStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrStringV(*v, e)
 
 	case map[uintptr]uint:
-		fastpathTV.EncMapUintptrUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUintV(v, e)
 	case *map[uintptr]uint:
-		fastpathTV.EncMapUintptrUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUintV(*v, e)
 
 	case map[uintptr]uint8:
-		fastpathTV.EncMapUintptrUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint8V(v, e)
 	case *map[uintptr]uint8:
-		fastpathTV.EncMapUintptrUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint8V(*v, e)
 
 	case map[uintptr]uint16:
-		fastpathTV.EncMapUintptrUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint16V(v, e)
 	case *map[uintptr]uint16:
-		fastpathTV.EncMapUintptrUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint16V(*v, e)
 
 	case map[uintptr]uint32:
-		fastpathTV.EncMapUintptrUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint32V(v, e)
 	case *map[uintptr]uint32:
-		fastpathTV.EncMapUintptrUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint32V(*v, e)
 
 	case map[uintptr]uint64:
-		fastpathTV.EncMapUintptrUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint64V(v, e)
 	case *map[uintptr]uint64:
-		fastpathTV.EncMapUintptrUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint64V(*v, e)
 
 	case map[uintptr]uintptr:
-		fastpathTV.EncMapUintptrUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUintptrV(v, e)
 	case *map[uintptr]uintptr:
-		fastpathTV.EncMapUintptrUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUintptrV(*v, e)
 
 	case map[uintptr]int:
-		fastpathTV.EncMapUintptrIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrIntV(v, e)
 	case *map[uintptr]int:
-		fastpathTV.EncMapUintptrIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrIntV(*v, e)
 
 	case map[uintptr]int8:
-		fastpathTV.EncMapUintptrInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt8V(v, e)
 	case *map[uintptr]int8:
-		fastpathTV.EncMapUintptrInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt8V(*v, e)
 
 	case map[uintptr]int16:
-		fastpathTV.EncMapUintptrInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt16V(v, e)
 	case *map[uintptr]int16:
-		fastpathTV.EncMapUintptrInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt16V(*v, e)
 
 	case map[uintptr]int32:
-		fastpathTV.EncMapUintptrInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt32V(v, e)
 	case *map[uintptr]int32:
-		fastpathTV.EncMapUintptrInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt32V(*v, e)
 
 	case map[uintptr]int64:
-		fastpathTV.EncMapUintptrInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt64V(v, e)
 	case *map[uintptr]int64:
-		fastpathTV.EncMapUintptrInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt64V(*v, e)
 
 	case map[uintptr]float32:
-		fastpathTV.EncMapUintptrFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrFloat32V(v, e)
 	case *map[uintptr]float32:
-		fastpathTV.EncMapUintptrFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrFloat32V(*v, e)
 
 	case map[uintptr]float64:
-		fastpathTV.EncMapUintptrFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrFloat64V(v, e)
 	case *map[uintptr]float64:
-		fastpathTV.EncMapUintptrFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrFloat64V(*v, e)
 
 	case map[uintptr]bool:
-		fastpathTV.EncMapUintptrBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrBoolV(v, e)
 	case *map[uintptr]bool:
-		fastpathTV.EncMapUintptrBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrBoolV(*v, e)
 
 	case []int:
-		fastpathTV.EncSliceIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceIntV(v, e)
 	case *[]int:
-		fastpathTV.EncSliceIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceIntV(*v, e)
 
 	case map[int]interface{}:
-		fastpathTV.EncMapIntIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntIntfV(v, e)
 	case *map[int]interface{}:
-		fastpathTV.EncMapIntIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntIntfV(*v, e)
 
 	case map[int]string:
-		fastpathTV.EncMapIntStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntStringV(v, e)
 	case *map[int]string:
-		fastpathTV.EncMapIntStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntStringV(*v, e)
 
 	case map[int]uint:
-		fastpathTV.EncMapIntUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUintV(v, e)
 	case *map[int]uint:
-		fastpathTV.EncMapIntUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUintV(*v, e)
 
 	case map[int]uint8:
-		fastpathTV.EncMapIntUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint8V(v, e)
 	case *map[int]uint8:
-		fastpathTV.EncMapIntUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint8V(*v, e)
 
 	case map[int]uint16:
-		fastpathTV.EncMapIntUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint16V(v, e)
 	case *map[int]uint16:
-		fastpathTV.EncMapIntUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint16V(*v, e)
 
 	case map[int]uint32:
-		fastpathTV.EncMapIntUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint32V(v, e)
 	case *map[int]uint32:
-		fastpathTV.EncMapIntUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint32V(*v, e)
 
 	case map[int]uint64:
-		fastpathTV.EncMapIntUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint64V(v, e)
 	case *map[int]uint64:
-		fastpathTV.EncMapIntUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint64V(*v, e)
 
 	case map[int]uintptr:
-		fastpathTV.EncMapIntUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUintptrV(v, e)
 	case *map[int]uintptr:
-		fastpathTV.EncMapIntUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUintptrV(*v, e)
 
 	case map[int]int:
-		fastpathTV.EncMapIntIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntIntV(v, e)
 	case *map[int]int:
-		fastpathTV.EncMapIntIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntIntV(*v, e)
 
 	case map[int]int8:
-		fastpathTV.EncMapIntInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt8V(v, e)
 	case *map[int]int8:
-		fastpathTV.EncMapIntInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt8V(*v, e)
 
 	case map[int]int16:
-		fastpathTV.EncMapIntInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt16V(v, e)
 	case *map[int]int16:
-		fastpathTV.EncMapIntInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt16V(*v, e)
 
 	case map[int]int32:
-		fastpathTV.EncMapIntInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt32V(v, e)
 	case *map[int]int32:
-		fastpathTV.EncMapIntInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt32V(*v, e)
 
 	case map[int]int64:
-		fastpathTV.EncMapIntInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt64V(v, e)
 	case *map[int]int64:
-		fastpathTV.EncMapIntInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt64V(*v, e)
 
 	case map[int]float32:
-		fastpathTV.EncMapIntFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntFloat32V(v, e)
 	case *map[int]float32:
-		fastpathTV.EncMapIntFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntFloat32V(*v, e)
 
 	case map[int]float64:
-		fastpathTV.EncMapIntFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntFloat64V(v, e)
 	case *map[int]float64:
-		fastpathTV.EncMapIntFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntFloat64V(*v, e)
 
 	case map[int]bool:
-		fastpathTV.EncMapIntBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntBoolV(v, e)
 	case *map[int]bool:
-		fastpathTV.EncMapIntBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntBoolV(*v, e)
 
 	case []int8:
-		fastpathTV.EncSliceInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt8V(v, e)
 	case *[]int8:
-		fastpathTV.EncSliceInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt8V(*v, e)
 
 	case map[int8]interface{}:
-		fastpathTV.EncMapInt8IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8IntfV(v, e)
 	case *map[int8]interface{}:
-		fastpathTV.EncMapInt8IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8IntfV(*v, e)
 
 	case map[int8]string:
-		fastpathTV.EncMapInt8StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8StringV(v, e)
 	case *map[int8]string:
-		fastpathTV.EncMapInt8StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8StringV(*v, e)
 
 	case map[int8]uint:
-		fastpathTV.EncMapInt8UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8UintV(v, e)
 	case *map[int8]uint:
-		fastpathTV.EncMapInt8UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8UintV(*v, e)
 
 	case map[int8]uint8:
-		fastpathTV.EncMapInt8Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint8V(v, e)
 	case *map[int8]uint8:
-		fastpathTV.EncMapInt8Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint8V(*v, e)
 
 	case map[int8]uint16:
-		fastpathTV.EncMapInt8Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint16V(v, e)
 	case *map[int8]uint16:
-		fastpathTV.EncMapInt8Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint16V(*v, e)
 
 	case map[int8]uint32:
-		fastpathTV.EncMapInt8Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint32V(v, e)
 	case *map[int8]uint32:
-		fastpathTV.EncMapInt8Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint32V(*v, e)
 
 	case map[int8]uint64:
-		fastpathTV.EncMapInt8Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint64V(v, e)
 	case *map[int8]uint64:
-		fastpathTV.EncMapInt8Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint64V(*v, e)
 
 	case map[int8]uintptr:
-		fastpathTV.EncMapInt8UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8UintptrV(v, e)
 	case *map[int8]uintptr:
-		fastpathTV.EncMapInt8UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8UintptrV(*v, e)
 
 	case map[int8]int:
-		fastpathTV.EncMapInt8IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8IntV(v, e)
 	case *map[int8]int:
-		fastpathTV.EncMapInt8IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8IntV(*v, e)
 
 	case map[int8]int8:
-		fastpathTV.EncMapInt8Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int8V(v, e)
 	case *map[int8]int8:
-		fastpathTV.EncMapInt8Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int8V(*v, e)
 
 	case map[int8]int16:
-		fastpathTV.EncMapInt8Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int16V(v, e)
 	case *map[int8]int16:
-		fastpathTV.EncMapInt8Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int16V(*v, e)
 
 	case map[int8]int32:
-		fastpathTV.EncMapInt8Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int32V(v, e)
 	case *map[int8]int32:
-		fastpathTV.EncMapInt8Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int32V(*v, e)
 
 	case map[int8]int64:
-		fastpathTV.EncMapInt8Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int64V(v, e)
 	case *map[int8]int64:
-		fastpathTV.EncMapInt8Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int64V(*v, e)
 
 	case map[int8]float32:
-		fastpathTV.EncMapInt8Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Float32V(v, e)
 	case *map[int8]float32:
-		fastpathTV.EncMapInt8Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Float32V(*v, e)
 
 	case map[int8]float64:
-		fastpathTV.EncMapInt8Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Float64V(v, e)
 	case *map[int8]float64:
-		fastpathTV.EncMapInt8Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Float64V(*v, e)
 
 	case map[int8]bool:
-		fastpathTV.EncMapInt8BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8BoolV(v, e)
 	case *map[int8]bool:
-		fastpathTV.EncMapInt8BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8BoolV(*v, e)
 
 	case []int16:
-		fastpathTV.EncSliceInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt16V(v, e)
 	case *[]int16:
-		fastpathTV.EncSliceInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt16V(*v, e)
 
 	case map[int16]interface{}:
-		fastpathTV.EncMapInt16IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16IntfV(v, e)
 	case *map[int16]interface{}:
-		fastpathTV.EncMapInt16IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16IntfV(*v, e)
 
 	case map[int16]string:
-		fastpathTV.EncMapInt16StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16StringV(v, e)
 	case *map[int16]string:
-		fastpathTV.EncMapInt16StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16StringV(*v, e)
 
 	case map[int16]uint:
-		fastpathTV.EncMapInt16UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16UintV(v, e)
 	case *map[int16]uint:
-		fastpathTV.EncMapInt16UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16UintV(*v, e)
 
 	case map[int16]uint8:
-		fastpathTV.EncMapInt16Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint8V(v, e)
 	case *map[int16]uint8:
-		fastpathTV.EncMapInt16Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint8V(*v, e)
 
 	case map[int16]uint16:
-		fastpathTV.EncMapInt16Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint16V(v, e)
 	case *map[int16]uint16:
-		fastpathTV.EncMapInt16Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint16V(*v, e)
 
 	case map[int16]uint32:
-		fastpathTV.EncMapInt16Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint32V(v, e)
 	case *map[int16]uint32:
-		fastpathTV.EncMapInt16Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint32V(*v, e)
 
 	case map[int16]uint64:
-		fastpathTV.EncMapInt16Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint64V(v, e)
 	case *map[int16]uint64:
-		fastpathTV.EncMapInt16Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint64V(*v, e)
 
 	case map[int16]uintptr:
-		fastpathTV.EncMapInt16UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16UintptrV(v, e)
 	case *map[int16]uintptr:
-		fastpathTV.EncMapInt16UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16UintptrV(*v, e)
 
 	case map[int16]int:
-		fastpathTV.EncMapInt16IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16IntV(v, e)
 	case *map[int16]int:
-		fastpathTV.EncMapInt16IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16IntV(*v, e)
 
 	case map[int16]int8:
-		fastpathTV.EncMapInt16Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int8V(v, e)
 	case *map[int16]int8:
-		fastpathTV.EncMapInt16Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int8V(*v, e)
 
 	case map[int16]int16:
-		fastpathTV.EncMapInt16Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int16V(v, e)
 	case *map[int16]int16:
-		fastpathTV.EncMapInt16Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int16V(*v, e)
 
 	case map[int16]int32:
-		fastpathTV.EncMapInt16Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int32V(v, e)
 	case *map[int16]int32:
-		fastpathTV.EncMapInt16Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int32V(*v, e)
 
 	case map[int16]int64:
-		fastpathTV.EncMapInt16Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int64V(v, e)
 	case *map[int16]int64:
-		fastpathTV.EncMapInt16Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int64V(*v, e)
 
 	case map[int16]float32:
-		fastpathTV.EncMapInt16Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Float32V(v, e)
 	case *map[int16]float32:
-		fastpathTV.EncMapInt16Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Float32V(*v, e)
 
 	case map[int16]float64:
-		fastpathTV.EncMapInt16Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Float64V(v, e)
 	case *map[int16]float64:
-		fastpathTV.EncMapInt16Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Float64V(*v, e)
 
 	case map[int16]bool:
-		fastpathTV.EncMapInt16BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16BoolV(v, e)
 	case *map[int16]bool:
-		fastpathTV.EncMapInt16BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16BoolV(*v, e)
 
 	case []int32:
-		fastpathTV.EncSliceInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt32V(v, e)
 	case *[]int32:
-		fastpathTV.EncSliceInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt32V(*v, e)
 
 	case map[int32]interface{}:
-		fastpathTV.EncMapInt32IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32IntfV(v, e)
 	case *map[int32]interface{}:
-		fastpathTV.EncMapInt32IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32IntfV(*v, e)
 
 	case map[int32]string:
-		fastpathTV.EncMapInt32StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32StringV(v, e)
 	case *map[int32]string:
-		fastpathTV.EncMapInt32StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32StringV(*v, e)
 
 	case map[int32]uint:
-		fastpathTV.EncMapInt32UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32UintV(v, e)
 	case *map[int32]uint:
-		fastpathTV.EncMapInt32UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32UintV(*v, e)
 
 	case map[int32]uint8:
-		fastpathTV.EncMapInt32Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint8V(v, e)
 	case *map[int32]uint8:
-		fastpathTV.EncMapInt32Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint8V(*v, e)
 
 	case map[int32]uint16:
-		fastpathTV.EncMapInt32Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint16V(v, e)
 	case *map[int32]uint16:
-		fastpathTV.EncMapInt32Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint16V(*v, e)
 
 	case map[int32]uint32:
-		fastpathTV.EncMapInt32Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint32V(v, e)
 	case *map[int32]uint32:
-		fastpathTV.EncMapInt32Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint32V(*v, e)
 
 	case map[int32]uint64:
-		fastpathTV.EncMapInt32Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint64V(v, e)
 	case *map[int32]uint64:
-		fastpathTV.EncMapInt32Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint64V(*v, e)
 
 	case map[int32]uintptr:
-		fastpathTV.EncMapInt32UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32UintptrV(v, e)
 	case *map[int32]uintptr:
-		fastpathTV.EncMapInt32UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32UintptrV(*v, e)
 
 	case map[int32]int:
-		fastpathTV.EncMapInt32IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32IntV(v, e)
 	case *map[int32]int:
-		fastpathTV.EncMapInt32IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32IntV(*v, e)
 
 	case map[int32]int8:
-		fastpathTV.EncMapInt32Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int8V(v, e)
 	case *map[int32]int8:
-		fastpathTV.EncMapInt32Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int8V(*v, e)
 
 	case map[int32]int16:
-		fastpathTV.EncMapInt32Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int16V(v, e)
 	case *map[int32]int16:
-		fastpathTV.EncMapInt32Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int16V(*v, e)
 
 	case map[int32]int32:
-		fastpathTV.EncMapInt32Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int32V(v, e)
 	case *map[int32]int32:
-		fastpathTV.EncMapInt32Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int32V(*v, e)
 
 	case map[int32]int64:
-		fastpathTV.EncMapInt32Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int64V(v, e)
 	case *map[int32]int64:
-		fastpathTV.EncMapInt32Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int64V(*v, e)
 
 	case map[int32]float32:
-		fastpathTV.EncMapInt32Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Float32V(v, e)
 	case *map[int32]float32:
-		fastpathTV.EncMapInt32Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Float32V(*v, e)
 
 	case map[int32]float64:
-		fastpathTV.EncMapInt32Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Float64V(v, e)
 	case *map[int32]float64:
-		fastpathTV.EncMapInt32Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Float64V(*v, e)
 
 	case map[int32]bool:
-		fastpathTV.EncMapInt32BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32BoolV(v, e)
 	case *map[int32]bool:
-		fastpathTV.EncMapInt32BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32BoolV(*v, e)
 
 	case []int64:
-		fastpathTV.EncSliceInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt64V(v, e)
 	case *[]int64:
-		fastpathTV.EncSliceInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt64V(*v, e)
 
 	case map[int64]interface{}:
-		fastpathTV.EncMapInt64IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64IntfV(v, e)
 	case *map[int64]interface{}:
-		fastpathTV.EncMapInt64IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64IntfV(*v, e)
 
 	case map[int64]string:
-		fastpathTV.EncMapInt64StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64StringV(v, e)
 	case *map[int64]string:
-		fastpathTV.EncMapInt64StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64StringV(*v, e)
 
 	case map[int64]uint:
-		fastpathTV.EncMapInt64UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64UintV(v, e)
 	case *map[int64]uint:
-		fastpathTV.EncMapInt64UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64UintV(*v, e)
 
 	case map[int64]uint8:
-		fastpathTV.EncMapInt64Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint8V(v, e)
 	case *map[int64]uint8:
-		fastpathTV.EncMapInt64Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint8V(*v, e)
 
 	case map[int64]uint16:
-		fastpathTV.EncMapInt64Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint16V(v, e)
 	case *map[int64]uint16:
-		fastpathTV.EncMapInt64Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint16V(*v, e)
 
 	case map[int64]uint32:
-		fastpathTV.EncMapInt64Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint32V(v, e)
 	case *map[int64]uint32:
-		fastpathTV.EncMapInt64Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint32V(*v, e)
 
 	case map[int64]uint64:
-		fastpathTV.EncMapInt64Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint64V(v, e)
 	case *map[int64]uint64:
-		fastpathTV.EncMapInt64Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint64V(*v, e)
 
 	case map[int64]uintptr:
-		fastpathTV.EncMapInt64UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64UintptrV(v, e)
 	case *map[int64]uintptr:
-		fastpathTV.EncMapInt64UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64UintptrV(*v, e)
 
 	case map[int64]int:
-		fastpathTV.EncMapInt64IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64IntV(v, e)
 	case *map[int64]int:
-		fastpathTV.EncMapInt64IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64IntV(*v, e)
 
 	case map[int64]int8:
-		fastpathTV.EncMapInt64Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int8V(v, e)
 	case *map[int64]int8:
-		fastpathTV.EncMapInt64Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int8V(*v, e)
 
 	case map[int64]int16:
-		fastpathTV.EncMapInt64Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int16V(v, e)
 	case *map[int64]int16:
-		fastpathTV.EncMapInt64Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int16V(*v, e)
 
 	case map[int64]int32:
-		fastpathTV.EncMapInt64Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int32V(v, e)
 	case *map[int64]int32:
-		fastpathTV.EncMapInt64Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int32V(*v, e)
 
 	case map[int64]int64:
-		fastpathTV.EncMapInt64Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int64V(v, e)
 	case *map[int64]int64:
-		fastpathTV.EncMapInt64Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int64V(*v, e)
 
 	case map[int64]float32:
-		fastpathTV.EncMapInt64Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Float32V(v, e)
 	case *map[int64]float32:
-		fastpathTV.EncMapInt64Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Float32V(*v, e)
 
 	case map[int64]float64:
-		fastpathTV.EncMapInt64Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Float64V(v, e)
 	case *map[int64]float64:
-		fastpathTV.EncMapInt64Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Float64V(*v, e)
 
 	case map[int64]bool:
-		fastpathTV.EncMapInt64BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64BoolV(v, e)
 	case *map[int64]bool:
-		fastpathTV.EncMapInt64BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64BoolV(*v, e)
 
 	case []bool:
-		fastpathTV.EncSliceBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceBoolV(v, e)
 	case *[]bool:
-		fastpathTV.EncSliceBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceBoolV(*v, e)
 
 	case map[bool]interface{}:
-		fastpathTV.EncMapBoolIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolIntfV(v, e)
 	case *map[bool]interface{}:
-		fastpathTV.EncMapBoolIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolIntfV(*v, e)
 
 	case map[bool]string:
-		fastpathTV.EncMapBoolStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolStringV(v, e)
 	case *map[bool]string:
-		fastpathTV.EncMapBoolStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolStringV(*v, e)
 
 	case map[bool]uint:
-		fastpathTV.EncMapBoolUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUintV(v, e)
 	case *map[bool]uint:
-		fastpathTV.EncMapBoolUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUintV(*v, e)
 
 	case map[bool]uint8:
-		fastpathTV.EncMapBoolUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint8V(v, e)
 	case *map[bool]uint8:
-		fastpathTV.EncMapBoolUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint8V(*v, e)
 
 	case map[bool]uint16:
-		fastpathTV.EncMapBoolUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint16V(v, e)
 	case *map[bool]uint16:
-		fastpathTV.EncMapBoolUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint16V(*v, e)
 
 	case map[bool]uint32:
-		fastpathTV.EncMapBoolUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint32V(v, e)
 	case *map[bool]uint32:
-		fastpathTV.EncMapBoolUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint32V(*v, e)
 
 	case map[bool]uint64:
-		fastpathTV.EncMapBoolUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint64V(v, e)
 	case *map[bool]uint64:
-		fastpathTV.EncMapBoolUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint64V(*v, e)
 
 	case map[bool]uintptr:
-		fastpathTV.EncMapBoolUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUintptrV(v, e)
 	case *map[bool]uintptr:
-		fastpathTV.EncMapBoolUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUintptrV(*v, e)
 
 	case map[bool]int:
-		fastpathTV.EncMapBoolIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolIntV(v, e)
 	case *map[bool]int:
-		fastpathTV.EncMapBoolIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolIntV(*v, e)
 
 	case map[bool]int8:
-		fastpathTV.EncMapBoolInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt8V(v, e)
 	case *map[bool]int8:
-		fastpathTV.EncMapBoolInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt8V(*v, e)
 
 	case map[bool]int16:
-		fastpathTV.EncMapBoolInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt16V(v, e)
 	case *map[bool]int16:
-		fastpathTV.EncMapBoolInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt16V(*v, e)
 
 	case map[bool]int32:
-		fastpathTV.EncMapBoolInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt32V(v, e)
 	case *map[bool]int32:
-		fastpathTV.EncMapBoolInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt32V(*v, e)
 
 	case map[bool]int64:
-		fastpathTV.EncMapBoolInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt64V(v, e)
 	case *map[bool]int64:
-		fastpathTV.EncMapBoolInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt64V(*v, e)
 
 	case map[bool]float32:
-		fastpathTV.EncMapBoolFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolFloat32V(v, e)
 	case *map[bool]float32:
-		fastpathTV.EncMapBoolFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolFloat32V(*v, e)
 
 	case map[bool]float64:
-		fastpathTV.EncMapBoolFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolFloat64V(v, e)
 	case *map[bool]float64:
-		fastpathTV.EncMapBoolFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolFloat64V(*v, e)
 
 	case map[bool]bool:
-		fastpathTV.EncMapBoolBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolBoolV(v, e)
 	case *map[bool]bool:
-		fastpathTV.EncMapBoolBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolBoolV(*v, e)
 
 	default:
 		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
@@ -1740,79 +1743,79 @@ func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
 	switch v := iv.(type) {
 
 	case []interface{}:
-		fastpathTV.EncSliceIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceIntfV(v, e)
 	case *[]interface{}:
-		fastpathTV.EncSliceIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceIntfV(*v, e)
 
 	case []string:
-		fastpathTV.EncSliceStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceStringV(v, e)
 	case *[]string:
-		fastpathTV.EncSliceStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceStringV(*v, e)
 
 	case []float32:
-		fastpathTV.EncSliceFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceFloat32V(v, e)
 	case *[]float32:
-		fastpathTV.EncSliceFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceFloat32V(*v, e)
 
 	case []float64:
-		fastpathTV.EncSliceFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceFloat64V(v, e)
 	case *[]float64:
-		fastpathTV.EncSliceFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceFloat64V(*v, e)
 
 	case []uint:
-		fastpathTV.EncSliceUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUintV(v, e)
 	case *[]uint:
-		fastpathTV.EncSliceUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUintV(*v, e)
 
 	case []uint16:
-		fastpathTV.EncSliceUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint16V(v, e)
 	case *[]uint16:
-		fastpathTV.EncSliceUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint16V(*v, e)
 
 	case []uint32:
-		fastpathTV.EncSliceUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint32V(v, e)
 	case *[]uint32:
-		fastpathTV.EncSliceUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint32V(*v, e)
 
 	case []uint64:
-		fastpathTV.EncSliceUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint64V(v, e)
 	case *[]uint64:
-		fastpathTV.EncSliceUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUint64V(*v, e)
 
 	case []uintptr:
-		fastpathTV.EncSliceUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUintptrV(v, e)
 	case *[]uintptr:
-		fastpathTV.EncSliceUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceUintptrV(*v, e)
 
 	case []int:
-		fastpathTV.EncSliceIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceIntV(v, e)
 	case *[]int:
-		fastpathTV.EncSliceIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceIntV(*v, e)
 
 	case []int8:
-		fastpathTV.EncSliceInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt8V(v, e)
 	case *[]int8:
-		fastpathTV.EncSliceInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt8V(*v, e)
 
 	case []int16:
-		fastpathTV.EncSliceInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt16V(v, e)
 	case *[]int16:
-		fastpathTV.EncSliceInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt16V(*v, e)
 
 	case []int32:
-		fastpathTV.EncSliceInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt32V(v, e)
 	case *[]int32:
-		fastpathTV.EncSliceInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt32V(*v, e)
 
 	case []int64:
-		fastpathTV.EncSliceInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt64V(v, e)
 	case *[]int64:
-		fastpathTV.EncSliceInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceInt64V(*v, e)
 
 	case []bool:
-		fastpathTV.EncSliceBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceBoolV(v, e)
 	case *[]bool:
-		fastpathTV.EncSliceBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceBoolV(*v, e)
 
 	default:
 		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
@@ -1825,1284 +1828,1284 @@ func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
 	switch v := iv.(type) {
 
 	case map[interface{}]interface{}:
-		fastpathTV.EncMapIntfIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfIntfV(v, e)
 	case *map[interface{}]interface{}:
-		fastpathTV.EncMapIntfIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfIntfV(*v, e)
 
 	case map[interface{}]string:
-		fastpathTV.EncMapIntfStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfStringV(v, e)
 	case *map[interface{}]string:
-		fastpathTV.EncMapIntfStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfStringV(*v, e)
 
 	case map[interface{}]uint:
-		fastpathTV.EncMapIntfUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUintV(v, e)
 	case *map[interface{}]uint:
-		fastpathTV.EncMapIntfUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUintV(*v, e)
 
 	case map[interface{}]uint8:
-		fastpathTV.EncMapIntfUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint8V(v, e)
 	case *map[interface{}]uint8:
-		fastpathTV.EncMapIntfUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint8V(*v, e)
 
 	case map[interface{}]uint16:
-		fastpathTV.EncMapIntfUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint16V(v, e)
 	case *map[interface{}]uint16:
-		fastpathTV.EncMapIntfUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint16V(*v, e)
 
 	case map[interface{}]uint32:
-		fastpathTV.EncMapIntfUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint32V(v, e)
 	case *map[interface{}]uint32:
-		fastpathTV.EncMapIntfUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint32V(*v, e)
 
 	case map[interface{}]uint64:
-		fastpathTV.EncMapIntfUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint64V(v, e)
 	case *map[interface{}]uint64:
-		fastpathTV.EncMapIntfUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint64V(*v, e)
 
 	case map[interface{}]uintptr:
-		fastpathTV.EncMapIntfUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUintptrV(v, e)
 	case *map[interface{}]uintptr:
-		fastpathTV.EncMapIntfUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUintptrV(*v, e)
 
 	case map[interface{}]int:
-		fastpathTV.EncMapIntfIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfIntV(v, e)
 	case *map[interface{}]int:
-		fastpathTV.EncMapIntfIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfIntV(*v, e)
 
 	case map[interface{}]int8:
-		fastpathTV.EncMapIntfInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt8V(v, e)
 	case *map[interface{}]int8:
-		fastpathTV.EncMapIntfInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt8V(*v, e)
 
 	case map[interface{}]int16:
-		fastpathTV.EncMapIntfInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt16V(v, e)
 	case *map[interface{}]int16:
-		fastpathTV.EncMapIntfInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt16V(*v, e)
 
 	case map[interface{}]int32:
-		fastpathTV.EncMapIntfInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt32V(v, e)
 	case *map[interface{}]int32:
-		fastpathTV.EncMapIntfInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt32V(*v, e)
 
 	case map[interface{}]int64:
-		fastpathTV.EncMapIntfInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt64V(v, e)
 	case *map[interface{}]int64:
-		fastpathTV.EncMapIntfInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt64V(*v, e)
 
 	case map[interface{}]float32:
-		fastpathTV.EncMapIntfFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfFloat32V(v, e)
 	case *map[interface{}]float32:
-		fastpathTV.EncMapIntfFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfFloat32V(*v, e)
 
 	case map[interface{}]float64:
-		fastpathTV.EncMapIntfFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfFloat64V(v, e)
 	case *map[interface{}]float64:
-		fastpathTV.EncMapIntfFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfFloat64V(*v, e)
 
 	case map[interface{}]bool:
-		fastpathTV.EncMapIntfBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfBoolV(v, e)
 	case *map[interface{}]bool:
-		fastpathTV.EncMapIntfBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfBoolV(*v, e)
 
 	case map[string]interface{}:
-		fastpathTV.EncMapStringIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringIntfV(v, e)
 	case *map[string]interface{}:
-		fastpathTV.EncMapStringIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringIntfV(*v, e)
 
 	case map[string]string:
-		fastpathTV.EncMapStringStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringStringV(v, e)
 	case *map[string]string:
-		fastpathTV.EncMapStringStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringStringV(*v, e)
 
 	case map[string]uint:
-		fastpathTV.EncMapStringUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUintV(v, e)
 	case *map[string]uint:
-		fastpathTV.EncMapStringUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUintV(*v, e)
 
 	case map[string]uint8:
-		fastpathTV.EncMapStringUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint8V(v, e)
 	case *map[string]uint8:
-		fastpathTV.EncMapStringUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint8V(*v, e)
 
 	case map[string]uint16:
-		fastpathTV.EncMapStringUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint16V(v, e)
 	case *map[string]uint16:
-		fastpathTV.EncMapStringUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint16V(*v, e)
 
 	case map[string]uint32:
-		fastpathTV.EncMapStringUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint32V(v, e)
 	case *map[string]uint32:
-		fastpathTV.EncMapStringUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint32V(*v, e)
 
 	case map[string]uint64:
-		fastpathTV.EncMapStringUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint64V(v, e)
 	case *map[string]uint64:
-		fastpathTV.EncMapStringUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint64V(*v, e)
 
 	case map[string]uintptr:
-		fastpathTV.EncMapStringUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUintptrV(v, e)
 	case *map[string]uintptr:
-		fastpathTV.EncMapStringUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUintptrV(*v, e)
 
 	case map[string]int:
-		fastpathTV.EncMapStringIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringIntV(v, e)
 	case *map[string]int:
-		fastpathTV.EncMapStringIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringIntV(*v, e)
 
 	case map[string]int8:
-		fastpathTV.EncMapStringInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt8V(v, e)
 	case *map[string]int8:
-		fastpathTV.EncMapStringInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt8V(*v, e)
 
 	case map[string]int16:
-		fastpathTV.EncMapStringInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt16V(v, e)
 	case *map[string]int16:
-		fastpathTV.EncMapStringInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt16V(*v, e)
 
 	case map[string]int32:
-		fastpathTV.EncMapStringInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt32V(v, e)
 	case *map[string]int32:
-		fastpathTV.EncMapStringInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt32V(*v, e)
 
 	case map[string]int64:
-		fastpathTV.EncMapStringInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt64V(v, e)
 	case *map[string]int64:
-		fastpathTV.EncMapStringInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt64V(*v, e)
 
 	case map[string]float32:
-		fastpathTV.EncMapStringFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringFloat32V(v, e)
 	case *map[string]float32:
-		fastpathTV.EncMapStringFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringFloat32V(*v, e)
 
 	case map[string]float64:
-		fastpathTV.EncMapStringFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringFloat64V(v, e)
 	case *map[string]float64:
-		fastpathTV.EncMapStringFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringFloat64V(*v, e)
 
 	case map[string]bool:
-		fastpathTV.EncMapStringBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringBoolV(v, e)
 	case *map[string]bool:
-		fastpathTV.EncMapStringBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringBoolV(*v, e)
 
 	case map[float32]interface{}:
-		fastpathTV.EncMapFloat32IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32IntfV(v, e)
 	case *map[float32]interface{}:
-		fastpathTV.EncMapFloat32IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32IntfV(*v, e)
 
 	case map[float32]string:
-		fastpathTV.EncMapFloat32StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32StringV(v, e)
 	case *map[float32]string:
-		fastpathTV.EncMapFloat32StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32StringV(*v, e)
 
 	case map[float32]uint:
-		fastpathTV.EncMapFloat32UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32UintV(v, e)
 	case *map[float32]uint:
-		fastpathTV.EncMapFloat32UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32UintV(*v, e)
 
 	case map[float32]uint8:
-		fastpathTV.EncMapFloat32Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint8V(v, e)
 	case *map[float32]uint8:
-		fastpathTV.EncMapFloat32Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint8V(*v, e)
 
 	case map[float32]uint16:
-		fastpathTV.EncMapFloat32Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint16V(v, e)
 	case *map[float32]uint16:
-		fastpathTV.EncMapFloat32Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint16V(*v, e)
 
 	case map[float32]uint32:
-		fastpathTV.EncMapFloat32Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint32V(v, e)
 	case *map[float32]uint32:
-		fastpathTV.EncMapFloat32Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint32V(*v, e)
 
 	case map[float32]uint64:
-		fastpathTV.EncMapFloat32Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint64V(v, e)
 	case *map[float32]uint64:
-		fastpathTV.EncMapFloat32Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint64V(*v, e)
 
 	case map[float32]uintptr:
-		fastpathTV.EncMapFloat32UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32UintptrV(v, e)
 	case *map[float32]uintptr:
-		fastpathTV.EncMapFloat32UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32UintptrV(*v, e)
 
 	case map[float32]int:
-		fastpathTV.EncMapFloat32IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32IntV(v, e)
 	case *map[float32]int:
-		fastpathTV.EncMapFloat32IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32IntV(*v, e)
 
 	case map[float32]int8:
-		fastpathTV.EncMapFloat32Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int8V(v, e)
 	case *map[float32]int8:
-		fastpathTV.EncMapFloat32Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int8V(*v, e)
 
 	case map[float32]int16:
-		fastpathTV.EncMapFloat32Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int16V(v, e)
 	case *map[float32]int16:
-		fastpathTV.EncMapFloat32Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int16V(*v, e)
 
 	case map[float32]int32:
-		fastpathTV.EncMapFloat32Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int32V(v, e)
 	case *map[float32]int32:
-		fastpathTV.EncMapFloat32Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int32V(*v, e)
 
 	case map[float32]int64:
-		fastpathTV.EncMapFloat32Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int64V(v, e)
 	case *map[float32]int64:
-		fastpathTV.EncMapFloat32Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int64V(*v, e)
 
 	case map[float32]float32:
-		fastpathTV.EncMapFloat32Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Float32V(v, e)
 	case *map[float32]float32:
-		fastpathTV.EncMapFloat32Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Float32V(*v, e)
 
 	case map[float32]float64:
-		fastpathTV.EncMapFloat32Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Float64V(v, e)
 	case *map[float32]float64:
-		fastpathTV.EncMapFloat32Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Float64V(*v, e)
 
 	case map[float32]bool:
-		fastpathTV.EncMapFloat32BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32BoolV(v, e)
 	case *map[float32]bool:
-		fastpathTV.EncMapFloat32BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32BoolV(*v, e)
 
 	case map[float64]interface{}:
-		fastpathTV.EncMapFloat64IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64IntfV(v, e)
 	case *map[float64]interface{}:
-		fastpathTV.EncMapFloat64IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64IntfV(*v, e)
 
 	case map[float64]string:
-		fastpathTV.EncMapFloat64StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64StringV(v, e)
 	case *map[float64]string:
-		fastpathTV.EncMapFloat64StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64StringV(*v, e)
 
 	case map[float64]uint:
-		fastpathTV.EncMapFloat64UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64UintV(v, e)
 	case *map[float64]uint:
-		fastpathTV.EncMapFloat64UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64UintV(*v, e)
 
 	case map[float64]uint8:
-		fastpathTV.EncMapFloat64Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint8V(v, e)
 	case *map[float64]uint8:
-		fastpathTV.EncMapFloat64Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint8V(*v, e)
 
 	case map[float64]uint16:
-		fastpathTV.EncMapFloat64Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint16V(v, e)
 	case *map[float64]uint16:
-		fastpathTV.EncMapFloat64Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint16V(*v, e)
 
 	case map[float64]uint32:
-		fastpathTV.EncMapFloat64Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint32V(v, e)
 	case *map[float64]uint32:
-		fastpathTV.EncMapFloat64Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint32V(*v, e)
 
 	case map[float64]uint64:
-		fastpathTV.EncMapFloat64Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint64V(v, e)
 	case *map[float64]uint64:
-		fastpathTV.EncMapFloat64Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint64V(*v, e)
 
 	case map[float64]uintptr:
-		fastpathTV.EncMapFloat64UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64UintptrV(v, e)
 	case *map[float64]uintptr:
-		fastpathTV.EncMapFloat64UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64UintptrV(*v, e)
 
 	case map[float64]int:
-		fastpathTV.EncMapFloat64IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64IntV(v, e)
 	case *map[float64]int:
-		fastpathTV.EncMapFloat64IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64IntV(*v, e)
 
 	case map[float64]int8:
-		fastpathTV.EncMapFloat64Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int8V(v, e)
 	case *map[float64]int8:
-		fastpathTV.EncMapFloat64Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int8V(*v, e)
 
 	case map[float64]int16:
-		fastpathTV.EncMapFloat64Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int16V(v, e)
 	case *map[float64]int16:
-		fastpathTV.EncMapFloat64Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int16V(*v, e)
 
 	case map[float64]int32:
-		fastpathTV.EncMapFloat64Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int32V(v, e)
 	case *map[float64]int32:
-		fastpathTV.EncMapFloat64Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int32V(*v, e)
 
 	case map[float64]int64:
-		fastpathTV.EncMapFloat64Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int64V(v, e)
 	case *map[float64]int64:
-		fastpathTV.EncMapFloat64Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int64V(*v, e)
 
 	case map[float64]float32:
-		fastpathTV.EncMapFloat64Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Float32V(v, e)
 	case *map[float64]float32:
-		fastpathTV.EncMapFloat64Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Float32V(*v, e)
 
 	case map[float64]float64:
-		fastpathTV.EncMapFloat64Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Float64V(v, e)
 	case *map[float64]float64:
-		fastpathTV.EncMapFloat64Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Float64V(*v, e)
 
 	case map[float64]bool:
-		fastpathTV.EncMapFloat64BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64BoolV(v, e)
 	case *map[float64]bool:
-		fastpathTV.EncMapFloat64BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64BoolV(*v, e)
 
 	case map[uint]interface{}:
-		fastpathTV.EncMapUintIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintIntfV(v, e)
 	case *map[uint]interface{}:
-		fastpathTV.EncMapUintIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintIntfV(*v, e)
 
 	case map[uint]string:
-		fastpathTV.EncMapUintStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintStringV(v, e)
 	case *map[uint]string:
-		fastpathTV.EncMapUintStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintStringV(*v, e)
 
 	case map[uint]uint:
-		fastpathTV.EncMapUintUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUintV(v, e)
 	case *map[uint]uint:
-		fastpathTV.EncMapUintUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUintV(*v, e)
 
 	case map[uint]uint8:
-		fastpathTV.EncMapUintUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint8V(v, e)
 	case *map[uint]uint8:
-		fastpathTV.EncMapUintUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint8V(*v, e)
 
 	case map[uint]uint16:
-		fastpathTV.EncMapUintUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint16V(v, e)
 	case *map[uint]uint16:
-		fastpathTV.EncMapUintUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint16V(*v, e)
 
 	case map[uint]uint32:
-		fastpathTV.EncMapUintUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint32V(v, e)
 	case *map[uint]uint32:
-		fastpathTV.EncMapUintUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint32V(*v, e)
 
 	case map[uint]uint64:
-		fastpathTV.EncMapUintUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint64V(v, e)
 	case *map[uint]uint64:
-		fastpathTV.EncMapUintUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint64V(*v, e)
 
 	case map[uint]uintptr:
-		fastpathTV.EncMapUintUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUintptrV(v, e)
 	case *map[uint]uintptr:
-		fastpathTV.EncMapUintUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUintptrV(*v, e)
 
 	case map[uint]int:
-		fastpathTV.EncMapUintIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintIntV(v, e)
 	case *map[uint]int:
-		fastpathTV.EncMapUintIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintIntV(*v, e)
 
 	case map[uint]int8:
-		fastpathTV.EncMapUintInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt8V(v, e)
 	case *map[uint]int8:
-		fastpathTV.EncMapUintInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt8V(*v, e)
 
 	case map[uint]int16:
-		fastpathTV.EncMapUintInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt16V(v, e)
 	case *map[uint]int16:
-		fastpathTV.EncMapUintInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt16V(*v, e)
 
 	case map[uint]int32:
-		fastpathTV.EncMapUintInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt32V(v, e)
 	case *map[uint]int32:
-		fastpathTV.EncMapUintInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt32V(*v, e)
 
 	case map[uint]int64:
-		fastpathTV.EncMapUintInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt64V(v, e)
 	case *map[uint]int64:
-		fastpathTV.EncMapUintInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt64V(*v, e)
 
 	case map[uint]float32:
-		fastpathTV.EncMapUintFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintFloat32V(v, e)
 	case *map[uint]float32:
-		fastpathTV.EncMapUintFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintFloat32V(*v, e)
 
 	case map[uint]float64:
-		fastpathTV.EncMapUintFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintFloat64V(v, e)
 	case *map[uint]float64:
-		fastpathTV.EncMapUintFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintFloat64V(*v, e)
 
 	case map[uint]bool:
-		fastpathTV.EncMapUintBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintBoolV(v, e)
 	case *map[uint]bool:
-		fastpathTV.EncMapUintBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintBoolV(*v, e)
 
 	case map[uint8]interface{}:
-		fastpathTV.EncMapUint8IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8IntfV(v, e)
 	case *map[uint8]interface{}:
-		fastpathTV.EncMapUint8IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8IntfV(*v, e)
 
 	case map[uint8]string:
-		fastpathTV.EncMapUint8StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8StringV(v, e)
 	case *map[uint8]string:
-		fastpathTV.EncMapUint8StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8StringV(*v, e)
 
 	case map[uint8]uint:
-		fastpathTV.EncMapUint8UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8UintV(v, e)
 	case *map[uint8]uint:
-		fastpathTV.EncMapUint8UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8UintV(*v, e)
 
 	case map[uint8]uint8:
-		fastpathTV.EncMapUint8Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint8V(v, e)
 	case *map[uint8]uint8:
-		fastpathTV.EncMapUint8Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint8V(*v, e)
 
 	case map[uint8]uint16:
-		fastpathTV.EncMapUint8Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint16V(v, e)
 	case *map[uint8]uint16:
-		fastpathTV.EncMapUint8Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint16V(*v, e)
 
 	case map[uint8]uint32:
-		fastpathTV.EncMapUint8Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint32V(v, e)
 	case *map[uint8]uint32:
-		fastpathTV.EncMapUint8Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint32V(*v, e)
 
 	case map[uint8]uint64:
-		fastpathTV.EncMapUint8Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint64V(v, e)
 	case *map[uint8]uint64:
-		fastpathTV.EncMapUint8Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint64V(*v, e)
 
 	case map[uint8]uintptr:
-		fastpathTV.EncMapUint8UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8UintptrV(v, e)
 	case *map[uint8]uintptr:
-		fastpathTV.EncMapUint8UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8UintptrV(*v, e)
 
 	case map[uint8]int:
-		fastpathTV.EncMapUint8IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8IntV(v, e)
 	case *map[uint8]int:
-		fastpathTV.EncMapUint8IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8IntV(*v, e)
 
 	case map[uint8]int8:
-		fastpathTV.EncMapUint8Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int8V(v, e)
 	case *map[uint8]int8:
-		fastpathTV.EncMapUint8Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int8V(*v, e)
 
 	case map[uint8]int16:
-		fastpathTV.EncMapUint8Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int16V(v, e)
 	case *map[uint8]int16:
-		fastpathTV.EncMapUint8Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int16V(*v, e)
 
 	case map[uint8]int32:
-		fastpathTV.EncMapUint8Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int32V(v, e)
 	case *map[uint8]int32:
-		fastpathTV.EncMapUint8Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int32V(*v, e)
 
 	case map[uint8]int64:
-		fastpathTV.EncMapUint8Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int64V(v, e)
 	case *map[uint8]int64:
-		fastpathTV.EncMapUint8Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int64V(*v, e)
 
 	case map[uint8]float32:
-		fastpathTV.EncMapUint8Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Float32V(v, e)
 	case *map[uint8]float32:
-		fastpathTV.EncMapUint8Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Float32V(*v, e)
 
 	case map[uint8]float64:
-		fastpathTV.EncMapUint8Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Float64V(v, e)
 	case *map[uint8]float64:
-		fastpathTV.EncMapUint8Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Float64V(*v, e)
 
 	case map[uint8]bool:
-		fastpathTV.EncMapUint8BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8BoolV(v, e)
 	case *map[uint8]bool:
-		fastpathTV.EncMapUint8BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8BoolV(*v, e)
 
 	case map[uint16]interface{}:
-		fastpathTV.EncMapUint16IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16IntfV(v, e)
 	case *map[uint16]interface{}:
-		fastpathTV.EncMapUint16IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16IntfV(*v, e)
 
 	case map[uint16]string:
-		fastpathTV.EncMapUint16StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16StringV(v, e)
 	case *map[uint16]string:
-		fastpathTV.EncMapUint16StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16StringV(*v, e)
 
 	case map[uint16]uint:
-		fastpathTV.EncMapUint16UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16UintV(v, e)
 	case *map[uint16]uint:
-		fastpathTV.EncMapUint16UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16UintV(*v, e)
 
 	case map[uint16]uint8:
-		fastpathTV.EncMapUint16Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint8V(v, e)
 	case *map[uint16]uint8:
-		fastpathTV.EncMapUint16Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint8V(*v, e)
 
 	case map[uint16]uint16:
-		fastpathTV.EncMapUint16Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint16V(v, e)
 	case *map[uint16]uint16:
-		fastpathTV.EncMapUint16Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint16V(*v, e)
 
 	case map[uint16]uint32:
-		fastpathTV.EncMapUint16Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint32V(v, e)
 	case *map[uint16]uint32:
-		fastpathTV.EncMapUint16Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint32V(*v, e)
 
 	case map[uint16]uint64:
-		fastpathTV.EncMapUint16Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint64V(v, e)
 	case *map[uint16]uint64:
-		fastpathTV.EncMapUint16Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint64V(*v, e)
 
 	case map[uint16]uintptr:
-		fastpathTV.EncMapUint16UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16UintptrV(v, e)
 	case *map[uint16]uintptr:
-		fastpathTV.EncMapUint16UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16UintptrV(*v, e)
 
 	case map[uint16]int:
-		fastpathTV.EncMapUint16IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16IntV(v, e)
 	case *map[uint16]int:
-		fastpathTV.EncMapUint16IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16IntV(*v, e)
 
 	case map[uint16]int8:
-		fastpathTV.EncMapUint16Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int8V(v, e)
 	case *map[uint16]int8:
-		fastpathTV.EncMapUint16Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int8V(*v, e)
 
 	case map[uint16]int16:
-		fastpathTV.EncMapUint16Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int16V(v, e)
 	case *map[uint16]int16:
-		fastpathTV.EncMapUint16Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int16V(*v, e)
 
 	case map[uint16]int32:
-		fastpathTV.EncMapUint16Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int32V(v, e)
 	case *map[uint16]int32:
-		fastpathTV.EncMapUint16Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int32V(*v, e)
 
 	case map[uint16]int64:
-		fastpathTV.EncMapUint16Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int64V(v, e)
 	case *map[uint16]int64:
-		fastpathTV.EncMapUint16Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int64V(*v, e)
 
 	case map[uint16]float32:
-		fastpathTV.EncMapUint16Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Float32V(v, e)
 	case *map[uint16]float32:
-		fastpathTV.EncMapUint16Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Float32V(*v, e)
 
 	case map[uint16]float64:
-		fastpathTV.EncMapUint16Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Float64V(v, e)
 	case *map[uint16]float64:
-		fastpathTV.EncMapUint16Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Float64V(*v, e)
 
 	case map[uint16]bool:
-		fastpathTV.EncMapUint16BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16BoolV(v, e)
 	case *map[uint16]bool:
-		fastpathTV.EncMapUint16BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16BoolV(*v, e)
 
 	case map[uint32]interface{}:
-		fastpathTV.EncMapUint32IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32IntfV(v, e)
 	case *map[uint32]interface{}:
-		fastpathTV.EncMapUint32IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32IntfV(*v, e)
 
 	case map[uint32]string:
-		fastpathTV.EncMapUint32StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32StringV(v, e)
 	case *map[uint32]string:
-		fastpathTV.EncMapUint32StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32StringV(*v, e)
 
 	case map[uint32]uint:
-		fastpathTV.EncMapUint32UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32UintV(v, e)
 	case *map[uint32]uint:
-		fastpathTV.EncMapUint32UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32UintV(*v, e)
 
 	case map[uint32]uint8:
-		fastpathTV.EncMapUint32Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint8V(v, e)
 	case *map[uint32]uint8:
-		fastpathTV.EncMapUint32Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint8V(*v, e)
 
 	case map[uint32]uint16:
-		fastpathTV.EncMapUint32Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint16V(v, e)
 	case *map[uint32]uint16:
-		fastpathTV.EncMapUint32Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint16V(*v, e)
 
 	case map[uint32]uint32:
-		fastpathTV.EncMapUint32Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint32V(v, e)
 	case *map[uint32]uint32:
-		fastpathTV.EncMapUint32Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint32V(*v, e)
 
 	case map[uint32]uint64:
-		fastpathTV.EncMapUint32Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint64V(v, e)
 	case *map[uint32]uint64:
-		fastpathTV.EncMapUint32Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint64V(*v, e)
 
 	case map[uint32]uintptr:
-		fastpathTV.EncMapUint32UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32UintptrV(v, e)
 	case *map[uint32]uintptr:
-		fastpathTV.EncMapUint32UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32UintptrV(*v, e)
 
 	case map[uint32]int:
-		fastpathTV.EncMapUint32IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32IntV(v, e)
 	case *map[uint32]int:
-		fastpathTV.EncMapUint32IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32IntV(*v, e)
 
 	case map[uint32]int8:
-		fastpathTV.EncMapUint32Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int8V(v, e)
 	case *map[uint32]int8:
-		fastpathTV.EncMapUint32Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int8V(*v, e)
 
 	case map[uint32]int16:
-		fastpathTV.EncMapUint32Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int16V(v, e)
 	case *map[uint32]int16:
-		fastpathTV.EncMapUint32Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int16V(*v, e)
 
 	case map[uint32]int32:
-		fastpathTV.EncMapUint32Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int32V(v, e)
 	case *map[uint32]int32:
-		fastpathTV.EncMapUint32Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int32V(*v, e)
 
 	case map[uint32]int64:
-		fastpathTV.EncMapUint32Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int64V(v, e)
 	case *map[uint32]int64:
-		fastpathTV.EncMapUint32Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int64V(*v, e)
 
 	case map[uint32]float32:
-		fastpathTV.EncMapUint32Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Float32V(v, e)
 	case *map[uint32]float32:
-		fastpathTV.EncMapUint32Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Float32V(*v, e)
 
 	case map[uint32]float64:
-		fastpathTV.EncMapUint32Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Float64V(v, e)
 	case *map[uint32]float64:
-		fastpathTV.EncMapUint32Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Float64V(*v, e)
 
 	case map[uint32]bool:
-		fastpathTV.EncMapUint32BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32BoolV(v, e)
 	case *map[uint32]bool:
-		fastpathTV.EncMapUint32BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32BoolV(*v, e)
 
 	case map[uint64]interface{}:
-		fastpathTV.EncMapUint64IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64IntfV(v, e)
 	case *map[uint64]interface{}:
-		fastpathTV.EncMapUint64IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64IntfV(*v, e)
 
 	case map[uint64]string:
-		fastpathTV.EncMapUint64StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64StringV(v, e)
 	case *map[uint64]string:
-		fastpathTV.EncMapUint64StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64StringV(*v, e)
 
 	case map[uint64]uint:
-		fastpathTV.EncMapUint64UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64UintV(v, e)
 	case *map[uint64]uint:
-		fastpathTV.EncMapUint64UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64UintV(*v, e)
 
 	case map[uint64]uint8:
-		fastpathTV.EncMapUint64Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint8V(v, e)
 	case *map[uint64]uint8:
-		fastpathTV.EncMapUint64Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint8V(*v, e)
 
 	case map[uint64]uint16:
-		fastpathTV.EncMapUint64Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint16V(v, e)
 	case *map[uint64]uint16:
-		fastpathTV.EncMapUint64Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint16V(*v, e)
 
 	case map[uint64]uint32:
-		fastpathTV.EncMapUint64Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint32V(v, e)
 	case *map[uint64]uint32:
-		fastpathTV.EncMapUint64Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint32V(*v, e)
 
 	case map[uint64]uint64:
-		fastpathTV.EncMapUint64Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint64V(v, e)
 	case *map[uint64]uint64:
-		fastpathTV.EncMapUint64Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint64V(*v, e)
 
 	case map[uint64]uintptr:
-		fastpathTV.EncMapUint64UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64UintptrV(v, e)
 	case *map[uint64]uintptr:
-		fastpathTV.EncMapUint64UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64UintptrV(*v, e)
 
 	case map[uint64]int:
-		fastpathTV.EncMapUint64IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64IntV(v, e)
 	case *map[uint64]int:
-		fastpathTV.EncMapUint64IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64IntV(*v, e)
 
 	case map[uint64]int8:
-		fastpathTV.EncMapUint64Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int8V(v, e)
 	case *map[uint64]int8:
-		fastpathTV.EncMapUint64Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int8V(*v, e)
 
 	case map[uint64]int16:
-		fastpathTV.EncMapUint64Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int16V(v, e)
 	case *map[uint64]int16:
-		fastpathTV.EncMapUint64Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int16V(*v, e)
 
 	case map[uint64]int32:
-		fastpathTV.EncMapUint64Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int32V(v, e)
 	case *map[uint64]int32:
-		fastpathTV.EncMapUint64Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int32V(*v, e)
 
 	case map[uint64]int64:
-		fastpathTV.EncMapUint64Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int64V(v, e)
 	case *map[uint64]int64:
-		fastpathTV.EncMapUint64Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int64V(*v, e)
 
 	case map[uint64]float32:
-		fastpathTV.EncMapUint64Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Float32V(v, e)
 	case *map[uint64]float32:
-		fastpathTV.EncMapUint64Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Float32V(*v, e)
 
 	case map[uint64]float64:
-		fastpathTV.EncMapUint64Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Float64V(v, e)
 	case *map[uint64]float64:
-		fastpathTV.EncMapUint64Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Float64V(*v, e)
 
 	case map[uint64]bool:
-		fastpathTV.EncMapUint64BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64BoolV(v, e)
 	case *map[uint64]bool:
-		fastpathTV.EncMapUint64BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64BoolV(*v, e)
 
 	case map[uintptr]interface{}:
-		fastpathTV.EncMapUintptrIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrIntfV(v, e)
 	case *map[uintptr]interface{}:
-		fastpathTV.EncMapUintptrIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrIntfV(*v, e)
 
 	case map[uintptr]string:
-		fastpathTV.EncMapUintptrStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrStringV(v, e)
 	case *map[uintptr]string:
-		fastpathTV.EncMapUintptrStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrStringV(*v, e)
 
 	case map[uintptr]uint:
-		fastpathTV.EncMapUintptrUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUintV(v, e)
 	case *map[uintptr]uint:
-		fastpathTV.EncMapUintptrUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUintV(*v, e)
 
 	case map[uintptr]uint8:
-		fastpathTV.EncMapUintptrUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint8V(v, e)
 	case *map[uintptr]uint8:
-		fastpathTV.EncMapUintptrUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint8V(*v, e)
 
 	case map[uintptr]uint16:
-		fastpathTV.EncMapUintptrUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint16V(v, e)
 	case *map[uintptr]uint16:
-		fastpathTV.EncMapUintptrUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint16V(*v, e)
 
 	case map[uintptr]uint32:
-		fastpathTV.EncMapUintptrUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint32V(v, e)
 	case *map[uintptr]uint32:
-		fastpathTV.EncMapUintptrUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint32V(*v, e)
 
 	case map[uintptr]uint64:
-		fastpathTV.EncMapUintptrUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint64V(v, e)
 	case *map[uintptr]uint64:
-		fastpathTV.EncMapUintptrUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint64V(*v, e)
 
 	case map[uintptr]uintptr:
-		fastpathTV.EncMapUintptrUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUintptrV(v, e)
 	case *map[uintptr]uintptr:
-		fastpathTV.EncMapUintptrUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUintptrV(*v, e)
 
 	case map[uintptr]int:
-		fastpathTV.EncMapUintptrIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrIntV(v, e)
 	case *map[uintptr]int:
-		fastpathTV.EncMapUintptrIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrIntV(*v, e)
 
 	case map[uintptr]int8:
-		fastpathTV.EncMapUintptrInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt8V(v, e)
 	case *map[uintptr]int8:
-		fastpathTV.EncMapUintptrInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt8V(*v, e)
 
 	case map[uintptr]int16:
-		fastpathTV.EncMapUintptrInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt16V(v, e)
 	case *map[uintptr]int16:
-		fastpathTV.EncMapUintptrInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt16V(*v, e)
 
 	case map[uintptr]int32:
-		fastpathTV.EncMapUintptrInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt32V(v, e)
 	case *map[uintptr]int32:
-		fastpathTV.EncMapUintptrInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt32V(*v, e)
 
 	case map[uintptr]int64:
-		fastpathTV.EncMapUintptrInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt64V(v, e)
 	case *map[uintptr]int64:
-		fastpathTV.EncMapUintptrInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt64V(*v, e)
 
 	case map[uintptr]float32:
-		fastpathTV.EncMapUintptrFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrFloat32V(v, e)
 	case *map[uintptr]float32:
-		fastpathTV.EncMapUintptrFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrFloat32V(*v, e)
 
 	case map[uintptr]float64:
-		fastpathTV.EncMapUintptrFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrFloat64V(v, e)
 	case *map[uintptr]float64:
-		fastpathTV.EncMapUintptrFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrFloat64V(*v, e)
 
 	case map[uintptr]bool:
-		fastpathTV.EncMapUintptrBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrBoolV(v, e)
 	case *map[uintptr]bool:
-		fastpathTV.EncMapUintptrBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrBoolV(*v, e)
 
 	case map[int]interface{}:
-		fastpathTV.EncMapIntIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntIntfV(v, e)
 	case *map[int]interface{}:
-		fastpathTV.EncMapIntIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntIntfV(*v, e)
 
 	case map[int]string:
-		fastpathTV.EncMapIntStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntStringV(v, e)
 	case *map[int]string:
-		fastpathTV.EncMapIntStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntStringV(*v, e)
 
 	case map[int]uint:
-		fastpathTV.EncMapIntUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUintV(v, e)
 	case *map[int]uint:
-		fastpathTV.EncMapIntUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUintV(*v, e)
 
 	case map[int]uint8:
-		fastpathTV.EncMapIntUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint8V(v, e)
 	case *map[int]uint8:
-		fastpathTV.EncMapIntUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint8V(*v, e)
 
 	case map[int]uint16:
-		fastpathTV.EncMapIntUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint16V(v, e)
 	case *map[int]uint16:
-		fastpathTV.EncMapIntUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint16V(*v, e)
 
 	case map[int]uint32:
-		fastpathTV.EncMapIntUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint32V(v, e)
 	case *map[int]uint32:
-		fastpathTV.EncMapIntUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint32V(*v, e)
 
 	case map[int]uint64:
-		fastpathTV.EncMapIntUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint64V(v, e)
 	case *map[int]uint64:
-		fastpathTV.EncMapIntUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint64V(*v, e)
 
 	case map[int]uintptr:
-		fastpathTV.EncMapIntUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUintptrV(v, e)
 	case *map[int]uintptr:
-		fastpathTV.EncMapIntUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUintptrV(*v, e)
 
 	case map[int]int:
-		fastpathTV.EncMapIntIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntIntV(v, e)
 	case *map[int]int:
-		fastpathTV.EncMapIntIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntIntV(*v, e)
 
 	case map[int]int8:
-		fastpathTV.EncMapIntInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt8V(v, e)
 	case *map[int]int8:
-		fastpathTV.EncMapIntInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt8V(*v, e)
 
 	case map[int]int16:
-		fastpathTV.EncMapIntInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt16V(v, e)
 	case *map[int]int16:
-		fastpathTV.EncMapIntInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt16V(*v, e)
 
 	case map[int]int32:
-		fastpathTV.EncMapIntInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt32V(v, e)
 	case *map[int]int32:
-		fastpathTV.EncMapIntInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt32V(*v, e)
 
 	case map[int]int64:
-		fastpathTV.EncMapIntInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt64V(v, e)
 	case *map[int]int64:
-		fastpathTV.EncMapIntInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt64V(*v, e)
 
 	case map[int]float32:
-		fastpathTV.EncMapIntFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntFloat32V(v, e)
 	case *map[int]float32:
-		fastpathTV.EncMapIntFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntFloat32V(*v, e)
 
 	case map[int]float64:
-		fastpathTV.EncMapIntFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntFloat64V(v, e)
 	case *map[int]float64:
-		fastpathTV.EncMapIntFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntFloat64V(*v, e)
 
 	case map[int]bool:
-		fastpathTV.EncMapIntBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntBoolV(v, e)
 	case *map[int]bool:
-		fastpathTV.EncMapIntBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntBoolV(*v, e)
 
 	case map[int8]interface{}:
-		fastpathTV.EncMapInt8IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8IntfV(v, e)
 	case *map[int8]interface{}:
-		fastpathTV.EncMapInt8IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8IntfV(*v, e)
 
 	case map[int8]string:
-		fastpathTV.EncMapInt8StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8StringV(v, e)
 	case *map[int8]string:
-		fastpathTV.EncMapInt8StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8StringV(*v, e)
 
 	case map[int8]uint:
-		fastpathTV.EncMapInt8UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8UintV(v, e)
 	case *map[int8]uint:
-		fastpathTV.EncMapInt8UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8UintV(*v, e)
 
 	case map[int8]uint8:
-		fastpathTV.EncMapInt8Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint8V(v, e)
 	case *map[int8]uint8:
-		fastpathTV.EncMapInt8Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint8V(*v, e)
 
 	case map[int8]uint16:
-		fastpathTV.EncMapInt8Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint16V(v, e)
 	case *map[int8]uint16:
-		fastpathTV.EncMapInt8Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint16V(*v, e)
 
 	case map[int8]uint32:
-		fastpathTV.EncMapInt8Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint32V(v, e)
 	case *map[int8]uint32:
-		fastpathTV.EncMapInt8Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint32V(*v, e)
 
 	case map[int8]uint64:
-		fastpathTV.EncMapInt8Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint64V(v, e)
 	case *map[int8]uint64:
-		fastpathTV.EncMapInt8Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint64V(*v, e)
 
 	case map[int8]uintptr:
-		fastpathTV.EncMapInt8UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8UintptrV(v, e)
 	case *map[int8]uintptr:
-		fastpathTV.EncMapInt8UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8UintptrV(*v, e)
 
 	case map[int8]int:
-		fastpathTV.EncMapInt8IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8IntV(v, e)
 	case *map[int8]int:
-		fastpathTV.EncMapInt8IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8IntV(*v, e)
 
 	case map[int8]int8:
-		fastpathTV.EncMapInt8Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int8V(v, e)
 	case *map[int8]int8:
-		fastpathTV.EncMapInt8Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int8V(*v, e)
 
 	case map[int8]int16:
-		fastpathTV.EncMapInt8Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int16V(v, e)
 	case *map[int8]int16:
-		fastpathTV.EncMapInt8Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int16V(*v, e)
 
 	case map[int8]int32:
-		fastpathTV.EncMapInt8Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int32V(v, e)
 	case *map[int8]int32:
-		fastpathTV.EncMapInt8Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int32V(*v, e)
 
 	case map[int8]int64:
-		fastpathTV.EncMapInt8Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int64V(v, e)
 	case *map[int8]int64:
-		fastpathTV.EncMapInt8Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int64V(*v, e)
 
 	case map[int8]float32:
-		fastpathTV.EncMapInt8Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Float32V(v, e)
 	case *map[int8]float32:
-		fastpathTV.EncMapInt8Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Float32V(*v, e)
 
 	case map[int8]float64:
-		fastpathTV.EncMapInt8Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Float64V(v, e)
 	case *map[int8]float64:
-		fastpathTV.EncMapInt8Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Float64V(*v, e)
 
 	case map[int8]bool:
-		fastpathTV.EncMapInt8BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8BoolV(v, e)
 	case *map[int8]bool:
-		fastpathTV.EncMapInt8BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8BoolV(*v, e)
 
 	case map[int16]interface{}:
-		fastpathTV.EncMapInt16IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16IntfV(v, e)
 	case *map[int16]interface{}:
-		fastpathTV.EncMapInt16IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16IntfV(*v, e)
 
 	case map[int16]string:
-		fastpathTV.EncMapInt16StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16StringV(v, e)
 	case *map[int16]string:
-		fastpathTV.EncMapInt16StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16StringV(*v, e)
 
 	case map[int16]uint:
-		fastpathTV.EncMapInt16UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16UintV(v, e)
 	case *map[int16]uint:
-		fastpathTV.EncMapInt16UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16UintV(*v, e)
 
 	case map[int16]uint8:
-		fastpathTV.EncMapInt16Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint8V(v, e)
 	case *map[int16]uint8:
-		fastpathTV.EncMapInt16Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint8V(*v, e)
 
 	case map[int16]uint16:
-		fastpathTV.EncMapInt16Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint16V(v, e)
 	case *map[int16]uint16:
-		fastpathTV.EncMapInt16Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint16V(*v, e)
 
 	case map[int16]uint32:
-		fastpathTV.EncMapInt16Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint32V(v, e)
 	case *map[int16]uint32:
-		fastpathTV.EncMapInt16Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint32V(*v, e)
 
 	case map[int16]uint64:
-		fastpathTV.EncMapInt16Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint64V(v, e)
 	case *map[int16]uint64:
-		fastpathTV.EncMapInt16Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint64V(*v, e)
 
 	case map[int16]uintptr:
-		fastpathTV.EncMapInt16UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16UintptrV(v, e)
 	case *map[int16]uintptr:
-		fastpathTV.EncMapInt16UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16UintptrV(*v, e)
 
 	case map[int16]int:
-		fastpathTV.EncMapInt16IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16IntV(v, e)
 	case *map[int16]int:
-		fastpathTV.EncMapInt16IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16IntV(*v, e)
 
 	case map[int16]int8:
-		fastpathTV.EncMapInt16Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int8V(v, e)
 	case *map[int16]int8:
-		fastpathTV.EncMapInt16Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int8V(*v, e)
 
 	case map[int16]int16:
-		fastpathTV.EncMapInt16Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int16V(v, e)
 	case *map[int16]int16:
-		fastpathTV.EncMapInt16Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int16V(*v, e)
 
 	case map[int16]int32:
-		fastpathTV.EncMapInt16Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int32V(v, e)
 	case *map[int16]int32:
-		fastpathTV.EncMapInt16Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int32V(*v, e)
 
 	case map[int16]int64:
-		fastpathTV.EncMapInt16Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int64V(v, e)
 	case *map[int16]int64:
-		fastpathTV.EncMapInt16Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int64V(*v, e)
 
 	case map[int16]float32:
-		fastpathTV.EncMapInt16Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Float32V(v, e)
 	case *map[int16]float32:
-		fastpathTV.EncMapInt16Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Float32V(*v, e)
 
 	case map[int16]float64:
-		fastpathTV.EncMapInt16Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Float64V(v, e)
 	case *map[int16]float64:
-		fastpathTV.EncMapInt16Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Float64V(*v, e)
 
 	case map[int16]bool:
-		fastpathTV.EncMapInt16BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16BoolV(v, e)
 	case *map[int16]bool:
-		fastpathTV.EncMapInt16BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16BoolV(*v, e)
 
 	case map[int32]interface{}:
-		fastpathTV.EncMapInt32IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32IntfV(v, e)
 	case *map[int32]interface{}:
-		fastpathTV.EncMapInt32IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32IntfV(*v, e)
 
 	case map[int32]string:
-		fastpathTV.EncMapInt32StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32StringV(v, e)
 	case *map[int32]string:
-		fastpathTV.EncMapInt32StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32StringV(*v, e)
 
 	case map[int32]uint:
-		fastpathTV.EncMapInt32UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32UintV(v, e)
 	case *map[int32]uint:
-		fastpathTV.EncMapInt32UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32UintV(*v, e)
 
 	case map[int32]uint8:
-		fastpathTV.EncMapInt32Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint8V(v, e)
 	case *map[int32]uint8:
-		fastpathTV.EncMapInt32Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint8V(*v, e)
 
 	case map[int32]uint16:
-		fastpathTV.EncMapInt32Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint16V(v, e)
 	case *map[int32]uint16:
-		fastpathTV.EncMapInt32Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint16V(*v, e)
 
 	case map[int32]uint32:
-		fastpathTV.EncMapInt32Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint32V(v, e)
 	case *map[int32]uint32:
-		fastpathTV.EncMapInt32Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint32V(*v, e)
 
 	case map[int32]uint64:
-		fastpathTV.EncMapInt32Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint64V(v, e)
 	case *map[int32]uint64:
-		fastpathTV.EncMapInt32Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint64V(*v, e)
 
 	case map[int32]uintptr:
-		fastpathTV.EncMapInt32UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32UintptrV(v, e)
 	case *map[int32]uintptr:
-		fastpathTV.EncMapInt32UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32UintptrV(*v, e)
 
 	case map[int32]int:
-		fastpathTV.EncMapInt32IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32IntV(v, e)
 	case *map[int32]int:
-		fastpathTV.EncMapInt32IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32IntV(*v, e)
 
 	case map[int32]int8:
-		fastpathTV.EncMapInt32Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int8V(v, e)
 	case *map[int32]int8:
-		fastpathTV.EncMapInt32Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int8V(*v, e)
 
 	case map[int32]int16:
-		fastpathTV.EncMapInt32Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int16V(v, e)
 	case *map[int32]int16:
-		fastpathTV.EncMapInt32Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int16V(*v, e)
 
 	case map[int32]int32:
-		fastpathTV.EncMapInt32Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int32V(v, e)
 	case *map[int32]int32:
-		fastpathTV.EncMapInt32Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int32V(*v, e)
 
 	case map[int32]int64:
-		fastpathTV.EncMapInt32Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int64V(v, e)
 	case *map[int32]int64:
-		fastpathTV.EncMapInt32Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int64V(*v, e)
 
 	case map[int32]float32:
-		fastpathTV.EncMapInt32Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Float32V(v, e)
 	case *map[int32]float32:
-		fastpathTV.EncMapInt32Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Float32V(*v, e)
 
 	case map[int32]float64:
-		fastpathTV.EncMapInt32Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Float64V(v, e)
 	case *map[int32]float64:
-		fastpathTV.EncMapInt32Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Float64V(*v, e)
 
 	case map[int32]bool:
-		fastpathTV.EncMapInt32BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32BoolV(v, e)
 	case *map[int32]bool:
-		fastpathTV.EncMapInt32BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32BoolV(*v, e)
 
 	case map[int64]interface{}:
-		fastpathTV.EncMapInt64IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64IntfV(v, e)
 	case *map[int64]interface{}:
-		fastpathTV.EncMapInt64IntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64IntfV(*v, e)
 
 	case map[int64]string:
-		fastpathTV.EncMapInt64StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64StringV(v, e)
 	case *map[int64]string:
-		fastpathTV.EncMapInt64StringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64StringV(*v, e)
 
 	case map[int64]uint:
-		fastpathTV.EncMapInt64UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64UintV(v, e)
 	case *map[int64]uint:
-		fastpathTV.EncMapInt64UintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64UintV(*v, e)
 
 	case map[int64]uint8:
-		fastpathTV.EncMapInt64Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint8V(v, e)
 	case *map[int64]uint8:
-		fastpathTV.EncMapInt64Uint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint8V(*v, e)
 
 	case map[int64]uint16:
-		fastpathTV.EncMapInt64Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint16V(v, e)
 	case *map[int64]uint16:
-		fastpathTV.EncMapInt64Uint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint16V(*v, e)
 
 	case map[int64]uint32:
-		fastpathTV.EncMapInt64Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint32V(v, e)
 	case *map[int64]uint32:
-		fastpathTV.EncMapInt64Uint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint32V(*v, e)
 
 	case map[int64]uint64:
-		fastpathTV.EncMapInt64Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint64V(v, e)
 	case *map[int64]uint64:
-		fastpathTV.EncMapInt64Uint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint64V(*v, e)
 
 	case map[int64]uintptr:
-		fastpathTV.EncMapInt64UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64UintptrV(v, e)
 	case *map[int64]uintptr:
-		fastpathTV.EncMapInt64UintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64UintptrV(*v, e)
 
 	case map[int64]int:
-		fastpathTV.EncMapInt64IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64IntV(v, e)
 	case *map[int64]int:
-		fastpathTV.EncMapInt64IntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64IntV(*v, e)
 
 	case map[int64]int8:
-		fastpathTV.EncMapInt64Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int8V(v, e)
 	case *map[int64]int8:
-		fastpathTV.EncMapInt64Int8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int8V(*v, e)
 
 	case map[int64]int16:
-		fastpathTV.EncMapInt64Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int16V(v, e)
 	case *map[int64]int16:
-		fastpathTV.EncMapInt64Int16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int16V(*v, e)
 
 	case map[int64]int32:
-		fastpathTV.EncMapInt64Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int32V(v, e)
 	case *map[int64]int32:
-		fastpathTV.EncMapInt64Int32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int32V(*v, e)
 
 	case map[int64]int64:
-		fastpathTV.EncMapInt64Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int64V(v, e)
 	case *map[int64]int64:
-		fastpathTV.EncMapInt64Int64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int64V(*v, e)
 
 	case map[int64]float32:
-		fastpathTV.EncMapInt64Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Float32V(v, e)
 	case *map[int64]float32:
-		fastpathTV.EncMapInt64Float32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Float32V(*v, e)
 
 	case map[int64]float64:
-		fastpathTV.EncMapInt64Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Float64V(v, e)
 	case *map[int64]float64:
-		fastpathTV.EncMapInt64Float64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Float64V(*v, e)
 
 	case map[int64]bool:
-		fastpathTV.EncMapInt64BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64BoolV(v, e)
 	case *map[int64]bool:
-		fastpathTV.EncMapInt64BoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64BoolV(*v, e)
 
 	case map[bool]interface{}:
-		fastpathTV.EncMapBoolIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolIntfV(v, e)
 	case *map[bool]interface{}:
-		fastpathTV.EncMapBoolIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolIntfV(*v, e)
 
 	case map[bool]string:
-		fastpathTV.EncMapBoolStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolStringV(v, e)
 	case *map[bool]string:
-		fastpathTV.EncMapBoolStringV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolStringV(*v, e)
 
 	case map[bool]uint:
-		fastpathTV.EncMapBoolUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUintV(v, e)
 	case *map[bool]uint:
-		fastpathTV.EncMapBoolUintV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUintV(*v, e)
 
 	case map[bool]uint8:
-		fastpathTV.EncMapBoolUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint8V(v, e)
 	case *map[bool]uint8:
-		fastpathTV.EncMapBoolUint8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint8V(*v, e)
 
 	case map[bool]uint16:
-		fastpathTV.EncMapBoolUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint16V(v, e)
 	case *map[bool]uint16:
-		fastpathTV.EncMapBoolUint16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint16V(*v, e)
 
 	case map[bool]uint32:
-		fastpathTV.EncMapBoolUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint32V(v, e)
 	case *map[bool]uint32:
-		fastpathTV.EncMapBoolUint32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint32V(*v, e)
 
 	case map[bool]uint64:
-		fastpathTV.EncMapBoolUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint64V(v, e)
 	case *map[bool]uint64:
-		fastpathTV.EncMapBoolUint64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint64V(*v, e)
 
 	case map[bool]uintptr:
-		fastpathTV.EncMapBoolUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUintptrV(v, e)
 	case *map[bool]uintptr:
-		fastpathTV.EncMapBoolUintptrV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUintptrV(*v, e)
 
 	case map[bool]int:
-		fastpathTV.EncMapBoolIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolIntV(v, e)
 	case *map[bool]int:
-		fastpathTV.EncMapBoolIntV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolIntV(*v, e)
 
 	case map[bool]int8:
-		fastpathTV.EncMapBoolInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt8V(v, e)
 	case *map[bool]int8:
-		fastpathTV.EncMapBoolInt8V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt8V(*v, e)
 
 	case map[bool]int16:
-		fastpathTV.EncMapBoolInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt16V(v, e)
 	case *map[bool]int16:
-		fastpathTV.EncMapBoolInt16V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt16V(*v, e)
 
 	case map[bool]int32:
-		fastpathTV.EncMapBoolInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt32V(v, e)
 	case *map[bool]int32:
-		fastpathTV.EncMapBoolInt32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt32V(*v, e)
 
 	case map[bool]int64:
-		fastpathTV.EncMapBoolInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt64V(v, e)
 	case *map[bool]int64:
-		fastpathTV.EncMapBoolInt64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt64V(*v, e)
 
 	case map[bool]float32:
-		fastpathTV.EncMapBoolFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolFloat32V(v, e)
 	case *map[bool]float32:
-		fastpathTV.EncMapBoolFloat32V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolFloat32V(*v, e)
 
 	case map[bool]float64:
-		fastpathTV.EncMapBoolFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolFloat64V(v, e)
 	case *map[bool]float64:
-		fastpathTV.EncMapBoolFloat64V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolFloat64V(*v, e)
 
 	case map[bool]bool:
-		fastpathTV.EncMapBoolBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolBoolV(v, e)
 	case *map[bool]bool:
-		fastpathTV.EncMapBoolBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolBoolV(*v, e)
 
 	default:
 		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
@@ -3113,812 +3116,597 @@ func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
 
 // -- -- fast path functions
 
-func (f *encFnInfo) fastpathEncSliceIntfR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceIntfR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceIntfV(rv.Interface().([]interface{}), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceIntfV(rv2i(rv).([]interface{}), e)
 	} else {
-		fastpathTV.EncSliceIntfV(rv.Interface().([]interface{}), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceIntfV(rv2i(rv).([]interface{}), e)
 	}
 }
-func (_ fastpathT) EncSliceIntfV(v []interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceIntfV(v []interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		e.encode(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceIntfV(v []interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceIntfV(v []interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		e.encode(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceStringR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceStringR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceStringV(rv2i(rv).([]string), e)
 	} else {
-		fastpathTV.EncSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceStringV(rv2i(rv).([]string), e)
 	}
 }
-func (_ fastpathT) EncSliceStringV(v []string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceStringV(v []string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeString(c_UTF8, v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceStringV(v []string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceStringV(v []string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeString(c_UTF8, v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceFloat32R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceFloat32V(rv2i(rv).([]float32), e)
 	} else {
-		fastpathTV.EncSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceFloat32V(rv2i(rv).([]float32), e)
 	}
 }
-func (_ fastpathT) EncSliceFloat32V(v []float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceFloat32V(v []float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeFloat32(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceFloat32V(v []float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceFloat32V(v []float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeFloat32(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceFloat64R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceFloat64V(rv2i(rv).([]float64), e)
 	} else {
-		fastpathTV.EncSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceFloat64V(rv2i(rv).([]float64), e)
 	}
 }
-func (_ fastpathT) EncSliceFloat64V(v []float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceFloat64V(v []float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeFloat64(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceFloat64V(v []float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceFloat64V(v []float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeFloat64(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceUintR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceUintR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceUintV(rv2i(rv).([]uint), e)
 	} else {
-		fastpathTV.EncSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceUintV(rv2i(rv).([]uint), e)
 	}
 }
-func (_ fastpathT) EncSliceUintV(v []uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceUintV(v []uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceUintV(v []uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceUintV(v []uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceUint16R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceUint16R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceUint16V(rv2i(rv).([]uint16), e)
 	} else {
-		fastpathTV.EncSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceUint16V(rv2i(rv).([]uint16), e)
 	}
 }
-func (_ fastpathT) EncSliceUint16V(v []uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceUint16V(v []uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceUint16V(v []uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceUint16V(v []uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceUint32R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceUint32R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceUint32V(rv2i(rv).([]uint32), e)
 	} else {
-		fastpathTV.EncSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceUint32V(rv2i(rv).([]uint32), e)
 	}
 }
-func (_ fastpathT) EncSliceUint32V(v []uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceUint32V(v []uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceUint32V(v []uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceUint32V(v []uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceUint64R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceUint64R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceUint64V(rv2i(rv).([]uint64), e)
 	} else {
-		fastpathTV.EncSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceUint64V(rv2i(rv).([]uint64), e)
 	}
 }
-func (_ fastpathT) EncSliceUint64V(v []uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceUint64V(v []uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceUint64V(v []uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceUint64V(v []uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceUintptrR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceUintptrV(rv2i(rv).([]uintptr), e)
 	} else {
-		fastpathTV.EncSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceUintptrV(rv2i(rv).([]uintptr), e)
 	}
 }
-func (_ fastpathT) EncSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceUintptrV(v []uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		e.encode(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceUintptrV(v []uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		e.encode(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceIntR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceIntR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceIntV(rv2i(rv).([]int), e)
 	} else {
-		fastpathTV.EncSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceIntV(rv2i(rv).([]int), e)
 	}
 }
-func (_ fastpathT) EncSliceIntV(v []int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceIntV(v []int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceIntV(v []int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceIntV(v []int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceInt8R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceInt8R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceInt8V(rv2i(rv).([]int8), e)
 	} else {
-		fastpathTV.EncSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceInt8V(rv2i(rv).([]int8), e)
 	}
 }
-func (_ fastpathT) EncSliceInt8V(v []int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceInt8V(v []int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceInt8V(v []int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceInt8V(v []int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceInt16R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceInt16R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceInt16V(rv2i(rv).([]int16), e)
 	} else {
-		fastpathTV.EncSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceInt16V(rv2i(rv).([]int16), e)
 	}
 }
-func (_ fastpathT) EncSliceInt16V(v []int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceInt16V(v []int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceInt16V(v []int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceInt16V(v []int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceInt32R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceInt32R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceInt32V(rv2i(rv).([]int32), e)
 	} else {
-		fastpathTV.EncSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceInt32V(rv2i(rv).([]int32), e)
 	}
 }
-func (_ fastpathT) EncSliceInt32V(v []int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceInt32V(v []int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceInt32V(v []int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceInt32V(v []int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceInt64R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceInt64R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceInt64V(rv2i(rv).([]int64), e)
 	} else {
-		fastpathTV.EncSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceInt64V(rv2i(rv).([]int64), e)
 	}
 }
-func (_ fastpathT) EncSliceInt64V(v []int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceInt64V(v []int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceInt64V(v []int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceInt64V(v []int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceBoolR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceBoolR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceBoolV(rv.Interface().([]bool), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceBoolV(rv2i(rv).([]bool), e)
 	} else {
-		fastpathTV.EncSliceBoolV(rv.Interface().([]bool), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceBoolV(rv2i(rv).([]bool), e)
 	}
 }
-func (_ fastpathT) EncSliceBoolV(v []bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) EncSliceBoolV(v []bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeBool(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceBoolV(v []bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceBoolV(v []bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeBool(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfIntfR(rv reflect.Value) {
-	fastpathTV.EncMapIntfIntfV(rv.Interface().(map[interface{}]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), e)
 }
-func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -3935,43 +3723,36 @@ func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, checkNil bool,
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfStringR(rv reflect.Value) {
-	fastpathTV.EncMapIntfStringV(rv.Interface().(map[interface{}]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfStringV(rv2i(rv).(map[interface{}]string), e)
 }
-func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -3988,43 +3769,36 @@ func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, checkNil bool, e
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUintR(rv reflect.Value) {
-	fastpathTV.EncMapIntfUintV(rv.Interface().(map[interface{}]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUintV(rv2i(rv).(map[interface{}]uint), e)
 }
-func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4041,43 +3815,36 @@ func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, checkNil bool, e *Enc
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUint8R(rv reflect.Value) {
-	fastpathTV.EncMapIntfUint8V(rv.Interface().(map[interface{}]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), e)
 }
-func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4094,43 +3861,36 @@ func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, checkNil bool, e *E
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUint16R(rv reflect.Value) {
-	fastpathTV.EncMapIntfUint16V(rv.Interface().(map[interface{}]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), e)
 }
-func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4147,43 +3907,36 @@ func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, checkNil bool, e
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUint32R(rv reflect.Value) {
-	fastpathTV.EncMapIntfUint32V(rv.Interface().(map[interface{}]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), e)
 }
-func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4200,43 +3953,36 @@ func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, checkNil bool, e
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUint64R(rv reflect.Value) {
-	fastpathTV.EncMapIntfUint64V(rv.Interface().(map[interface{}]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), e)
 }
-func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4253,43 +3999,36 @@ func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, checkNil bool, e
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapIntfUintptrV(rv.Interface().(map[interface{}]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), e)
 }
-func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4306,43 +4045,36 @@ func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool,
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfIntR(rv reflect.Value) {
-	fastpathTV.EncMapIntfIntV(rv.Interface().(map[interface{}]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfIntV(rv2i(rv).(map[interface{}]int), e)
 }
-func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4359,43 +4091,36 @@ func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, checkNil bool, e *Encod
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfInt8R(rv reflect.Value) {
-	fastpathTV.EncMapIntfInt8V(rv.Interface().(map[interface{}]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfInt8V(rv2i(rv).(map[interface{}]int8), e)
 }
-func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4412,43 +4137,36 @@ func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, checkNil bool, e *Enc
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfInt16R(rv reflect.Value) {
-	fastpathTV.EncMapIntfInt16V(rv.Interface().(map[interface{}]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfInt16V(rv2i(rv).(map[interface{}]int16), e)
 }
-func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4465,43 +4183,36 @@ func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, checkNil bool, e *E
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfInt32R(rv reflect.Value) {
-	fastpathTV.EncMapIntfInt32V(rv.Interface().(map[interface{}]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfInt32V(rv2i(rv).(map[interface{}]int32), e)
 }
-func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4518,43 +4229,36 @@ func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, checkNil bool, e *E
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfInt64R(rv reflect.Value) {
-	fastpathTV.EncMapIntfInt64V(rv.Interface().(map[interface{}]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfInt64V(rv2i(rv).(map[interface{}]int64), e)
 }
-func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4571,43 +4275,36 @@ func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, checkNil bool, e *E
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapIntfFloat32V(rv.Interface().(map[interface{}]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), e)
 }
-func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4624,43 +4321,36 @@ func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, checkNil bool,
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapIntfFloat64V(rv.Interface().(map[interface{}]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), e)
 }
-func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4677,43 +4367,36 @@ func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, checkNil bool,
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfBoolR(rv reflect.Value) {
-	fastpathTV.EncMapIntfBoolV(rv.Interface().(map[interface{}]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfBoolV(rv2i(rv).(map[interface{}]bool), e)
 }
-func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4730,43 +4413,36 @@ func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, checkNil bool, e *Enc
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringIntfR(rv reflect.Value) {
-	fastpathTV.EncMapStringIntfV(rv.Interface().(map[string]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringIntfV(rv2i(rv).(map[string]interface{}), e)
 }
-func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -4777,51 +4453,44 @@ func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, checkNil bool, e
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringStringR(rv reflect.Value) {
-	fastpathTV.EncMapStringStringV(rv.Interface().(map[string]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringStringV(rv2i(rv).(map[string]string), e)
 }
-func (_ fastpathT) EncMapStringStringV(v map[string]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringStringV(v map[string]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -4832,51 +4501,44 @@ func (_ fastpathT) EncMapStringStringV(v map[string]string, checkNil bool, e *En
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUintR(rv reflect.Value) {
-	fastpathTV.EncMapStringUintV(rv.Interface().(map[string]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUintV(rv2i(rv).(map[string]uint), e)
 }
-func (_ fastpathT) EncMapStringUintV(v map[string]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringUintV(v map[string]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -4887,51 +4549,44 @@ func (_ fastpathT) EncMapStringUintV(v map[string]uint, checkNil bool, e *Encode
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUint8R(rv reflect.Value) {
-	fastpathTV.EncMapStringUint8V(rv.Interface().(map[string]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUint8V(rv2i(rv).(map[string]uint8), e)
 }
-func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -4942,51 +4597,44 @@ func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, checkNil bool, e *Enco
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUint16R(rv reflect.Value) {
-	fastpathTV.EncMapStringUint16V(rv.Interface().(map[string]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUint16V(rv2i(rv).(map[string]uint16), e)
 }
-func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -4997,51 +4645,44 @@ func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, checkNil bool, e *En
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUint32R(rv reflect.Value) {
-	fastpathTV.EncMapStringUint32V(rv.Interface().(map[string]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUint32V(rv2i(rv).(map[string]uint32), e)
 }
-func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5052,51 +4693,44 @@ func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, checkNil bool, e *En
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUint64R(rv reflect.Value) {
-	fastpathTV.EncMapStringUint64V(rv.Interface().(map[string]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUint64V(rv2i(rv).(map[string]uint64), e)
 }
-func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5107,51 +4741,44 @@ func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, checkNil bool, e *En
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapStringUintptrV(rv.Interface().(map[string]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUintptrV(rv2i(rv).(map[string]uintptr), e)
 }
-func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5162,51 +4789,44 @@ func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, checkNil bool, e *
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringIntR(rv reflect.Value) {
-	fastpathTV.EncMapStringIntV(rv.Interface().(map[string]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringIntV(rv2i(rv).(map[string]int), e)
 }
-func (_ fastpathT) EncMapStringIntV(v map[string]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringIntV(v map[string]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5217,51 +4837,44 @@ func (_ fastpathT) EncMapStringIntV(v map[string]int, checkNil bool, e *Encoder)
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringInt8R(rv reflect.Value) {
-	fastpathTV.EncMapStringInt8V(rv.Interface().(map[string]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringInt8V(rv2i(rv).(map[string]int8), e)
 }
-func (_ fastpathT) EncMapStringInt8V(v map[string]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringInt8V(v map[string]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5272,51 +4885,44 @@ func (_ fastpathT) EncMapStringInt8V(v map[string]int8, checkNil bool, e *Encode
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringInt16R(rv reflect.Value) {
-	fastpathTV.EncMapStringInt16V(rv.Interface().(map[string]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringInt16V(rv2i(rv).(map[string]int16), e)
 }
-func (_ fastpathT) EncMapStringInt16V(v map[string]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringInt16V(v map[string]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5327,51 +4933,44 @@ func (_ fastpathT) EncMapStringInt16V(v map[string]int16, checkNil bool, e *Enco
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringInt32R(rv reflect.Value) {
-	fastpathTV.EncMapStringInt32V(rv.Interface().(map[string]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringInt32V(rv2i(rv).(map[string]int32), e)
 }
-func (_ fastpathT) EncMapStringInt32V(v map[string]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringInt32V(v map[string]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5382,51 +4981,44 @@ func (_ fastpathT) EncMapStringInt32V(v map[string]int32, checkNil bool, e *Enco
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringInt64R(rv reflect.Value) {
-	fastpathTV.EncMapStringInt64V(rv.Interface().(map[string]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringInt64V(rv2i(rv).(map[string]int64), e)
 }
-func (_ fastpathT) EncMapStringInt64V(v map[string]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringInt64V(v map[string]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5437,51 +5029,44 @@ func (_ fastpathT) EncMapStringInt64V(v map[string]int64, checkNil bool, e *Enco
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapStringFloat32V(rv.Interface().(map[string]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringFloat32V(rv2i(rv).(map[string]float32), e)
 }
-func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5492,51 +5077,44 @@ func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, checkNil bool, e *
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapStringFloat64V(rv.Interface().(map[string]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringFloat64V(rv2i(rv).(map[string]float64), e)
 }
-func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5547,51 +5125,44 @@ func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, checkNil bool, e *
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringBoolR(rv reflect.Value) {
-	fastpathTV.EncMapStringBoolV(rv.Interface().(map[string]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringBoolV(rv2i(rv).(map[string]bool), e)
 }
-func (_ fastpathT) EncMapStringBoolV(v map[string]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapStringBoolV(v map[string]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5602,51 +5173,44 @@ func (_ fastpathT) EncMapStringBoolV(v map[string]bool, checkNil bool, e *Encode
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32IntfR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32IntfV(rv.Interface().(map[float32]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), e)
 }
-func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5656,43 +5220,36 @@ func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, checkNil bool,
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32StringR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32StringV(rv.Interface().(map[float32]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32StringV(rv2i(rv).(map[float32]string), e)
 }
-func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5702,43 +5259,36 @@ func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32UintR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32UintV(rv.Interface().(map[float32]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32UintV(rv2i(rv).(map[float32]uint), e)
 }
-func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5748,43 +5298,36 @@ func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Uint8V(rv.Interface().(map[float32]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), e)
 }
-func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5794,43 +5337,36 @@ func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Uint16V(rv.Interface().(map[float32]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), e)
 }
-func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5840,43 +5376,36 @@ func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Uint32V(rv.Interface().(map[float32]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), e)
 }
-func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5886,43 +5415,36 @@ func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Uint64V(rv.Interface().(map[float32]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), e)
 }
-func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5932,43 +5454,36 @@ func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32UintptrV(rv.Interface().(map[float32]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), e)
 }
-func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5978,43 +5493,36 @@ func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32IntR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32IntV(rv.Interface().(map[float32]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32IntV(rv2i(rv).(map[float32]int), e)
 }
-func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6024,43 +5532,36 @@ func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, checkNil bool, e *Encode
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Int8R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Int8V(rv.Interface().(map[float32]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Int8V(rv2i(rv).(map[float32]int8), e)
 }
-func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6070,43 +5571,36 @@ func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Int16R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Int16V(rv.Interface().(map[float32]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Int16V(rv2i(rv).(map[float32]int16), e)
 }
-func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6116,43 +5610,36 @@ func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Int32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Int32V(rv.Interface().(map[float32]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Int32V(rv2i(rv).(map[float32]int32), e)
 }
-func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6162,43 +5649,36 @@ func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Int64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Int64V(rv.Interface().(map[float32]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Int64V(rv2i(rv).(map[float32]int64), e)
 }
-func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6208,43 +5688,36 @@ func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Float32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Float32V(rv.Interface().(map[float32]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Float32V(rv2i(rv).(map[float32]float32), e)
 }
-func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6254,43 +5727,36 @@ func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Float64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Float64V(rv.Interface().(map[float32]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Float64V(rv2i(rv).(map[float32]float64), e)
 }
-func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6300,43 +5766,36 @@ func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32BoolR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32BoolV(rv.Interface().(map[float32]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32BoolV(rv2i(rv).(map[float32]bool), e)
 }
-func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6346,43 +5805,36 @@ func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64IntfR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64IntfV(rv.Interface().(map[float64]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), e)
 }
-func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6392,43 +5844,36 @@ func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, checkNil bool,
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64StringR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64StringV(rv.Interface().(map[float64]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64StringV(rv2i(rv).(map[float64]string), e)
 }
-func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6438,43 +5883,36 @@ func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64UintR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64UintV(rv.Interface().(map[float64]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64UintV(rv2i(rv).(map[float64]uint), e)
 }
-func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6484,43 +5922,36 @@ func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Uint8V(rv.Interface().(map[float64]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), e)
 }
-func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6530,43 +5961,36 @@ func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Uint16V(rv.Interface().(map[float64]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), e)
 }
-func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6576,43 +6000,36 @@ func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Uint32V(rv.Interface().(map[float64]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), e)
 }
-func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6622,43 +6039,36 @@ func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Uint64V(rv.Interface().(map[float64]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), e)
 }
-func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6668,43 +6078,36 @@ func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64UintptrV(rv.Interface().(map[float64]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), e)
 }
-func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6714,43 +6117,36 @@ func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64IntR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64IntV(rv.Interface().(map[float64]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64IntV(rv2i(rv).(map[float64]int), e)
 }
-func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6760,43 +6156,36 @@ func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, checkNil bool, e *Encode
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Int8R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Int8V(rv.Interface().(map[float64]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Int8V(rv2i(rv).(map[float64]int8), e)
 }
-func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6806,43 +6195,36 @@ func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Int16R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Int16V(rv.Interface().(map[float64]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Int16V(rv2i(rv).(map[float64]int16), e)
 }
-func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6852,43 +6234,36 @@ func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Int32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Int32V(rv.Interface().(map[float64]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Int32V(rv2i(rv).(map[float64]int32), e)
 }
-func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6898,43 +6273,36 @@ func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Int64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Int64V(rv.Interface().(map[float64]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Int64V(rv2i(rv).(map[float64]int64), e)
 }
-func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6944,43 +6312,36 @@ func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Float32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Float32V(rv.Interface().(map[float64]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Float32V(rv2i(rv).(map[float64]float32), e)
 }
-func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6990,43 +6351,36 @@ func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Float64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Float64V(rv.Interface().(map[float64]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Float64V(rv2i(rv).(map[float64]float64), e)
 }
-func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -7036,43 +6390,36 @@ func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64BoolR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64BoolV(rv.Interface().(map[float64]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64BoolV(rv2i(rv).(map[float64]bool), e)
 }
-func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -7082,43 +6429,36 @@ func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintIntfR(rv reflect.Value) {
-	fastpathTV.EncMapUintIntfV(rv.Interface().(map[uint]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintIntfV(rv2i(rv).(map[uint]interface{}), e)
 }
-func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7128,43 +6468,36 @@ func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, checkNil bool, e *Enc
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintStringR(rv reflect.Value) {
-	fastpathTV.EncMapUintStringV(rv.Interface().(map[uint]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintStringV(rv2i(rv).(map[uint]string), e)
 }
-func (_ fastpathT) EncMapUintStringV(v map[uint]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintStringV(v map[uint]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7174,43 +6507,36 @@ func (_ fastpathT) EncMapUintStringV(v map[uint]string, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUintR(rv reflect.Value) {
-	fastpathTV.EncMapUintUintV(rv.Interface().(map[uint]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUintV(rv2i(rv).(map[uint]uint), e)
 }
-func (_ fastpathT) EncMapUintUintV(v map[uint]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintUintV(v map[uint]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7220,43 +6546,36 @@ func (_ fastpathT) EncMapUintUintV(v map[uint]uint, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUint8R(rv reflect.Value) {
-	fastpathTV.EncMapUintUint8V(rv.Interface().(map[uint]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUint8V(rv2i(rv).(map[uint]uint8), e)
 }
-func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7266,43 +6585,36 @@ func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUint16R(rv reflect.Value) {
-	fastpathTV.EncMapUintUint16V(rv.Interface().(map[uint]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUint16V(rv2i(rv).(map[uint]uint16), e)
 }
-func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7312,43 +6624,36 @@ func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUint32R(rv reflect.Value) {
-	fastpathTV.EncMapUintUint32V(rv.Interface().(map[uint]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUint32V(rv2i(rv).(map[uint]uint32), e)
 }
-func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7358,43 +6663,36 @@ func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUint64R(rv reflect.Value) {
-	fastpathTV.EncMapUintUint64V(rv.Interface().(map[uint]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUint64V(rv2i(rv).(map[uint]uint64), e)
 }
-func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7404,43 +6702,36 @@ func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUintUintptrV(rv.Interface().(map[uint]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUintptrV(rv2i(rv).(map[uint]uintptr), e)
 }
-func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7450,43 +6741,36 @@ func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintIntR(rv reflect.Value) {
-	fastpathTV.EncMapUintIntV(rv.Interface().(map[uint]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintIntV(rv2i(rv).(map[uint]int), e)
 }
-func (_ fastpathT) EncMapUintIntV(v map[uint]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintIntV(v map[uint]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7496,43 +6780,36 @@ func (_ fastpathT) EncMapUintIntV(v map[uint]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintInt8R(rv reflect.Value) {
-	fastpathTV.EncMapUintInt8V(rv.Interface().(map[uint]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintInt8V(rv2i(rv).(map[uint]int8), e)
 }
-func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7542,43 +6819,36 @@ func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintInt16R(rv reflect.Value) {
-	fastpathTV.EncMapUintInt16V(rv.Interface().(map[uint]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintInt16V(rv2i(rv).(map[uint]int16), e)
 }
-func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7588,43 +6858,36 @@ func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintInt32R(rv reflect.Value) {
-	fastpathTV.EncMapUintInt32V(rv.Interface().(map[uint]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintInt32V(rv2i(rv).(map[uint]int32), e)
 }
-func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7634,43 +6897,36 @@ func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintInt64R(rv reflect.Value) {
-	fastpathTV.EncMapUintInt64V(rv.Interface().(map[uint]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintInt64V(rv2i(rv).(map[uint]int64), e)
 }
-func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7680,43 +6936,36 @@ func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapUintFloat32V(rv.Interface().(map[uint]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintFloat32V(rv2i(rv).(map[uint]float32), e)
 }
-func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7726,43 +6975,36 @@ func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapUintFloat64V(rv.Interface().(map[uint]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintFloat64V(rv2i(rv).(map[uint]float64), e)
 }
-func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7772,43 +7014,36 @@ func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintBoolR(rv reflect.Value) {
-	fastpathTV.EncMapUintBoolV(rv.Interface().(map[uint]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintBoolV(rv2i(rv).(map[uint]bool), e)
 }
-func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7818,43 +7053,36 @@ func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8IntfR(rv reflect.Value) {
-	fastpathTV.EncMapUint8IntfV(rv.Interface().(map[uint8]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), e)
 }
-func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7864,43 +7092,36 @@ func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, checkNil bool, e *E
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8StringR(rv reflect.Value) {
-	fastpathTV.EncMapUint8StringV(rv.Interface().(map[uint8]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8StringV(rv2i(rv).(map[uint8]string), e)
 }
-func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7910,43 +7131,36 @@ func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8UintR(rv reflect.Value) {
-	fastpathTV.EncMapUint8UintV(rv.Interface().(map[uint8]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8UintV(rv2i(rv).(map[uint8]uint), e)
 }
-func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7956,43 +7170,36 @@ func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Uint8V(rv.Interface().(map[uint8]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), e)
 }
-func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8002,43 +7209,36 @@ func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Uint16V(rv.Interface().(map[uint8]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), e)
 }
-func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8048,43 +7248,36 @@ func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Uint32V(rv.Interface().(map[uint8]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), e)
 }
-func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8094,43 +7287,36 @@ func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Uint64V(rv.Interface().(map[uint8]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), e)
 }
-func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8140,43 +7326,36 @@ func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUint8UintptrV(rv.Interface().(map[uint8]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), e)
 }
-func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8186,43 +7365,36 @@ func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8IntR(rv reflect.Value) {
-	fastpathTV.EncMapUint8IntV(rv.Interface().(map[uint8]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8IntV(rv2i(rv).(map[uint8]int), e)
 }
-func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8232,43 +7404,36 @@ func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Int8R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Int8V(rv.Interface().(map[uint8]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Int8V(rv2i(rv).(map[uint8]int8), e)
 }
-func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8278,43 +7443,36 @@ func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Int16R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Int16V(rv.Interface().(map[uint8]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Int16V(rv2i(rv).(map[uint8]int16), e)
 }
-func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8324,43 +7482,36 @@ func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Int32R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Int32V(rv.Interface().(map[uint8]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Int32V(rv2i(rv).(map[uint8]int32), e)
 }
-func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8370,43 +7521,36 @@ func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Int64R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Int64V(rv.Interface().(map[uint8]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Int64V(rv2i(rv).(map[uint8]int64), e)
 }
-func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8416,43 +7560,36 @@ func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Float32R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Float32V(rv.Interface().(map[uint8]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Float32V(rv2i(rv).(map[uint8]float32), e)
 }
-func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8462,43 +7599,36 @@ func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Float64R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Float64V(rv.Interface().(map[uint8]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Float64V(rv2i(rv).(map[uint8]float64), e)
 }
-func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8508,43 +7638,36 @@ func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8BoolR(rv reflect.Value) {
-	fastpathTV.EncMapUint8BoolV(rv.Interface().(map[uint8]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8BoolV(rv2i(rv).(map[uint8]bool), e)
 }
-func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8554,43 +7677,36 @@ func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16IntfR(rv reflect.Value) {
-	fastpathTV.EncMapUint16IntfV(rv.Interface().(map[uint16]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), e)
 }
-func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8600,43 +7716,36 @@ func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16StringR(rv reflect.Value) {
-	fastpathTV.EncMapUint16StringV(rv.Interface().(map[uint16]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16StringV(rv2i(rv).(map[uint16]string), e)
 }
-func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8646,43 +7755,36 @@ func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16UintR(rv reflect.Value) {
-	fastpathTV.EncMapUint16UintV(rv.Interface().(map[uint16]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16UintV(rv2i(rv).(map[uint16]uint), e)
 }
-func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8692,43 +7794,36 @@ func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Uint8V(rv.Interface().(map[uint16]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), e)
 }
-func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8738,43 +7833,36 @@ func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Uint16V(rv.Interface().(map[uint16]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), e)
 }
-func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8784,43 +7872,36 @@ func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Uint32V(rv.Interface().(map[uint16]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), e)
 }
-func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8830,43 +7911,36 @@ func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Uint64V(rv.Interface().(map[uint16]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), e)
 }
-func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8876,43 +7950,36 @@ func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUint16UintptrV(rv.Interface().(map[uint16]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), e)
 }
-func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8922,43 +7989,36 @@ func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16IntR(rv reflect.Value) {
-	fastpathTV.EncMapUint16IntV(rv.Interface().(map[uint16]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16IntV(rv2i(rv).(map[uint16]int), e)
 }
-func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8968,43 +8028,36 @@ func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Int8R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Int8V(rv.Interface().(map[uint16]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Int8V(rv2i(rv).(map[uint16]int8), e)
 }
-func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9014,43 +8067,36 @@ func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Int16R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Int16V(rv.Interface().(map[uint16]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Int16V(rv2i(rv).(map[uint16]int16), e)
 }
-func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9060,43 +8106,36 @@ func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Int32R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Int32V(rv.Interface().(map[uint16]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Int32V(rv2i(rv).(map[uint16]int32), e)
 }
-func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9106,43 +8145,36 @@ func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Int64R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Int64V(rv.Interface().(map[uint16]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Int64V(rv2i(rv).(map[uint16]int64), e)
 }
-func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9152,43 +8184,36 @@ func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Float32R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Float32V(rv.Interface().(map[uint16]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Float32V(rv2i(rv).(map[uint16]float32), e)
 }
-func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9198,43 +8223,36 @@ func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Float64R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Float64V(rv.Interface().(map[uint16]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Float64V(rv2i(rv).(map[uint16]float64), e)
 }
-func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9244,43 +8262,36 @@ func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16BoolR(rv reflect.Value) {
-	fastpathTV.EncMapUint16BoolV(rv.Interface().(map[uint16]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16BoolV(rv2i(rv).(map[uint16]bool), e)
 }
-func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9290,43 +8301,36 @@ func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32IntfR(rv reflect.Value) {
-	fastpathTV.EncMapUint32IntfV(rv.Interface().(map[uint32]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), e)
 }
-func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9336,43 +8340,36 @@ func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32StringR(rv reflect.Value) {
-	fastpathTV.EncMapUint32StringV(rv.Interface().(map[uint32]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32StringV(rv2i(rv).(map[uint32]string), e)
 }
-func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9382,43 +8379,36 @@ func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32UintR(rv reflect.Value) {
-	fastpathTV.EncMapUint32UintV(rv.Interface().(map[uint32]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32UintV(rv2i(rv).(map[uint32]uint), e)
 }
-func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9428,43 +8418,36 @@ func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Uint8V(rv.Interface().(map[uint32]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), e)
 }
-func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9474,43 +8457,36 @@ func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Uint16V(rv.Interface().(map[uint32]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), e)
 }
-func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9520,43 +8496,36 @@ func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Uint32V(rv.Interface().(map[uint32]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), e)
 }
-func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9566,43 +8535,36 @@ func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Uint64V(rv.Interface().(map[uint32]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), e)
 }
-func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9612,43 +8574,36 @@ func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUint32UintptrV(rv.Interface().(map[uint32]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), e)
 }
-func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9658,43 +8613,36 @@ func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32IntR(rv reflect.Value) {
-	fastpathTV.EncMapUint32IntV(rv.Interface().(map[uint32]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32IntV(rv2i(rv).(map[uint32]int), e)
 }
-func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9704,43 +8652,36 @@ func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Int8R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Int8V(rv.Interface().(map[uint32]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Int8V(rv2i(rv).(map[uint32]int8), e)
 }
-func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9750,43 +8691,36 @@ func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Int16R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Int16V(rv.Interface().(map[uint32]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Int16V(rv2i(rv).(map[uint32]int16), e)
 }
-func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9796,43 +8730,36 @@ func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Int32R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Int32V(rv.Interface().(map[uint32]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Int32V(rv2i(rv).(map[uint32]int32), e)
 }
-func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9842,43 +8769,36 @@ func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Int64R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Int64V(rv.Interface().(map[uint32]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Int64V(rv2i(rv).(map[uint32]int64), e)
 }
-func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9888,43 +8808,36 @@ func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Float32R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Float32V(rv.Interface().(map[uint32]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Float32V(rv2i(rv).(map[uint32]float32), e)
 }
-func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9934,43 +8847,36 @@ func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Float64R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Float64V(rv.Interface().(map[uint32]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Float64V(rv2i(rv).(map[uint32]float64), e)
 }
-func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9980,43 +8886,36 @@ func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32BoolR(rv reflect.Value) {
-	fastpathTV.EncMapUint32BoolV(rv.Interface().(map[uint32]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32BoolV(rv2i(rv).(map[uint32]bool), e)
 }
-func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10026,43 +8925,36 @@ func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64IntfR(rv reflect.Value) {
-	fastpathTV.EncMapUint64IntfV(rv.Interface().(map[uint64]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), e)
 }
-func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10072,43 +8964,36 @@ func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64StringR(rv reflect.Value) {
-	fastpathTV.EncMapUint64StringV(rv.Interface().(map[uint64]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64StringV(rv2i(rv).(map[uint64]string), e)
 }
-func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10118,43 +9003,36 @@ func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64UintR(rv reflect.Value) {
-	fastpathTV.EncMapUint64UintV(rv.Interface().(map[uint64]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64UintV(rv2i(rv).(map[uint64]uint), e)
 }
-func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10164,43 +9042,36 @@ func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Uint8V(rv.Interface().(map[uint64]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), e)
 }
-func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10210,43 +9081,36 @@ func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Uint16V(rv.Interface().(map[uint64]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), e)
 }
-func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10256,43 +9120,36 @@ func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Uint32V(rv.Interface().(map[uint64]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), e)
 }
-func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10302,43 +9159,36 @@ func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Uint64V(rv.Interface().(map[uint64]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), e)
 }
-func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10348,43 +9198,36 @@ func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUint64UintptrV(rv.Interface().(map[uint64]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), e)
 }
-func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10394,43 +9237,36 @@ func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64IntR(rv reflect.Value) {
-	fastpathTV.EncMapUint64IntV(rv.Interface().(map[uint64]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64IntV(rv2i(rv).(map[uint64]int), e)
 }
-func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10440,43 +9276,36 @@ func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Int8R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Int8V(rv.Interface().(map[uint64]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Int8V(rv2i(rv).(map[uint64]int8), e)
 }
-func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10486,43 +9315,36 @@ func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Int16R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Int16V(rv.Interface().(map[uint64]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Int16V(rv2i(rv).(map[uint64]int16), e)
 }
-func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10532,43 +9354,36 @@ func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Int32R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Int32V(rv.Interface().(map[uint64]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Int32V(rv2i(rv).(map[uint64]int32), e)
 }
-func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10578,43 +9393,36 @@ func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Int64R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Int64V(rv.Interface().(map[uint64]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Int64V(rv2i(rv).(map[uint64]int64), e)
 }
-func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10624,43 +9432,36 @@ func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Float32R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Float32V(rv.Interface().(map[uint64]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Float32V(rv2i(rv).(map[uint64]float32), e)
 }
-func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10670,43 +9471,36 @@ func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Float64R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Float64V(rv.Interface().(map[uint64]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Float64V(rv2i(rv).(map[uint64]float64), e)
 }
-func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10716,43 +9510,36 @@ func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64BoolR(rv reflect.Value) {
-	fastpathTV.EncMapUint64BoolV(rv.Interface().(map[uint64]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64BoolV(rv2i(rv).(map[uint64]bool), e)
 }
-func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10762,43 +9549,36 @@ func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrIntfR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrIntfV(rv.Interface().(map[uintptr]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), e)
 }
-func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10808,43 +9588,36 @@ func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool,
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrStringR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrStringV(rv.Interface().(map[uintptr]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrStringV(rv2i(rv).(map[uintptr]string), e)
 }
-func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10854,43 +9627,36 @@ func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUintR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUintV(rv.Interface().(map[uintptr]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUintV(rv2i(rv).(map[uintptr]uint), e)
 }
-func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10900,43 +9666,36 @@ func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUint8R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUint8V(rv.Interface().(map[uintptr]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), e)
 }
-func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10946,43 +9705,36 @@ func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUint16R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUint16V(rv.Interface().(map[uintptr]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), e)
 }
-func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10992,43 +9744,36 @@ func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUint32R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUint32V(rv.Interface().(map[uintptr]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), e)
 }
-func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11038,43 +9783,36 @@ func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUint64R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUint64V(rv.Interface().(map[uintptr]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), e)
 }
-func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11084,43 +9822,36 @@ func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUintptrV(rv.Interface().(map[uintptr]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), e)
 }
-func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11130,43 +9861,36 @@ func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrIntR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrIntV(rv.Interface().(map[uintptr]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrIntV(rv2i(rv).(map[uintptr]int), e)
 }
-func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11176,43 +9900,36 @@ func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrInt8R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrInt8V(rv.Interface().(map[uintptr]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), e)
 }
-func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11222,43 +9939,36 @@ func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrInt16R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrInt16V(rv.Interface().(map[uintptr]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), e)
 }
-func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11268,43 +9978,36 @@ func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrInt32R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrInt32V(rv.Interface().(map[uintptr]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), e)
 }
-func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11314,43 +10017,36 @@ func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrInt64R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrInt64V(rv.Interface().(map[uintptr]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), e)
 }
-func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11360,43 +10056,36 @@ func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrFloat32V(rv.Interface().(map[uintptr]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), e)
 }
-func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11406,43 +10095,36 @@ func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrFloat64V(rv.Interface().(map[uintptr]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), e)
 }
-func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11452,43 +10134,36 @@ func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrBoolR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrBoolV(rv.Interface().(map[uintptr]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), e)
 }
-func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11498,43 +10173,36 @@ func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntIntfR(rv reflect.Value) {
-	fastpathTV.EncMapIntIntfV(rv.Interface().(map[int]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntIntfV(rv2i(rv).(map[int]interface{}), e)
 }
-func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11544,43 +10212,36 @@ func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, checkNil bool, e *Encod
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntStringR(rv reflect.Value) {
-	fastpathTV.EncMapIntStringV(rv.Interface().(map[int]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntStringV(rv2i(rv).(map[int]string), e)
 }
-func (_ fastpathT) EncMapIntStringV(v map[int]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntStringV(v map[int]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11590,43 +10251,36 @@ func (_ fastpathT) EncMapIntStringV(v map[int]string, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUintR(rv reflect.Value) {
-	fastpathTV.EncMapIntUintV(rv.Interface().(map[int]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUintV(rv2i(rv).(map[int]uint), e)
 }
-func (_ fastpathT) EncMapIntUintV(v map[int]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntUintV(v map[int]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11636,43 +10290,36 @@ func (_ fastpathT) EncMapIntUintV(v map[int]uint, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUint8R(rv reflect.Value) {
-	fastpathTV.EncMapIntUint8V(rv.Interface().(map[int]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUint8V(rv2i(rv).(map[int]uint8), e)
 }
-func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11682,43 +10329,36 @@ func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUint16R(rv reflect.Value) {
-	fastpathTV.EncMapIntUint16V(rv.Interface().(map[int]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUint16V(rv2i(rv).(map[int]uint16), e)
 }
-func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11728,43 +10368,36 @@ func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUint32R(rv reflect.Value) {
-	fastpathTV.EncMapIntUint32V(rv.Interface().(map[int]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUint32V(rv2i(rv).(map[int]uint32), e)
 }
-func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11774,43 +10407,36 @@ func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUint64R(rv reflect.Value) {
-	fastpathTV.EncMapIntUint64V(rv.Interface().(map[int]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUint64V(rv2i(rv).(map[int]uint64), e)
 }
-func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11820,43 +10446,36 @@ func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapIntUintptrV(rv.Interface().(map[int]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUintptrV(rv2i(rv).(map[int]uintptr), e)
 }
-func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11866,43 +10485,36 @@ func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntIntR(rv reflect.Value) {
-	fastpathTV.EncMapIntIntV(rv.Interface().(map[int]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntIntV(rv2i(rv).(map[int]int), e)
 }
-func (_ fastpathT) EncMapIntIntV(v map[int]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntIntV(v map[int]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11912,43 +10524,36 @@ func (_ fastpathT) EncMapIntIntV(v map[int]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntInt8R(rv reflect.Value) {
-	fastpathTV.EncMapIntInt8V(rv.Interface().(map[int]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntInt8V(rv2i(rv).(map[int]int8), e)
 }
-func (_ fastpathT) EncMapIntInt8V(v map[int]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntInt8V(v map[int]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11958,43 +10563,36 @@ func (_ fastpathT) EncMapIntInt8V(v map[int]int8, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntInt16R(rv reflect.Value) {
-	fastpathTV.EncMapIntInt16V(rv.Interface().(map[int]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntInt16V(rv2i(rv).(map[int]int16), e)
 }
-func (_ fastpathT) EncMapIntInt16V(v map[int]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntInt16V(v map[int]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12004,43 +10602,36 @@ func (_ fastpathT) EncMapIntInt16V(v map[int]int16, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntInt32R(rv reflect.Value) {
-	fastpathTV.EncMapIntInt32V(rv.Interface().(map[int]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntInt32V(rv2i(rv).(map[int]int32), e)
 }
-func (_ fastpathT) EncMapIntInt32V(v map[int]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntInt32V(v map[int]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12050,43 +10641,36 @@ func (_ fastpathT) EncMapIntInt32V(v map[int]int32, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntInt64R(rv reflect.Value) {
-	fastpathTV.EncMapIntInt64V(rv.Interface().(map[int]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntInt64V(rv2i(rv).(map[int]int64), e)
 }
-func (_ fastpathT) EncMapIntInt64V(v map[int]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntInt64V(v map[int]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12096,43 +10680,36 @@ func (_ fastpathT) EncMapIntInt64V(v map[int]int64, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapIntFloat32V(rv.Interface().(map[int]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntFloat32V(rv2i(rv).(map[int]float32), e)
 }
-func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12142,43 +10719,36 @@ func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapIntFloat64V(rv.Interface().(map[int]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntFloat64V(rv2i(rv).(map[int]float64), e)
 }
-func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12188,43 +10758,36 @@ func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntBoolR(rv reflect.Value) {
-	fastpathTV.EncMapIntBoolV(rv.Interface().(map[int]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntBoolV(rv2i(rv).(map[int]bool), e)
 }
-func (_ fastpathT) EncMapIntBoolV(v map[int]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapIntBoolV(v map[int]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12234,43 +10797,36 @@ func (_ fastpathT) EncMapIntBoolV(v map[int]bool, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8IntfR(rv reflect.Value) {
-	fastpathTV.EncMapInt8IntfV(rv.Interface().(map[int8]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8IntfV(rv2i(rv).(map[int8]interface{}), e)
 }
-func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12280,43 +10836,36 @@ func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, checkNil bool, e *Enc
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8StringR(rv reflect.Value) {
-	fastpathTV.EncMapInt8StringV(rv.Interface().(map[int8]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8StringV(rv2i(rv).(map[int8]string), e)
 }
-func (_ fastpathT) EncMapInt8StringV(v map[int8]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8StringV(v map[int8]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12326,43 +10875,36 @@ func (_ fastpathT) EncMapInt8StringV(v map[int8]string, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8UintR(rv reflect.Value) {
-	fastpathTV.EncMapInt8UintV(rv.Interface().(map[int8]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8UintV(rv2i(rv).(map[int8]uint), e)
 }
-func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12372,43 +10914,36 @@ func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Uint8V(rv.Interface().(map[int8]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Uint8V(rv2i(rv).(map[int8]uint8), e)
 }
-func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12418,43 +10953,36 @@ func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Uint16V(rv.Interface().(map[int8]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Uint16V(rv2i(rv).(map[int8]uint16), e)
 }
-func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12464,43 +10992,36 @@ func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Uint32V(rv.Interface().(map[int8]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Uint32V(rv2i(rv).(map[int8]uint32), e)
 }
-func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12510,43 +11031,36 @@ func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Uint64V(rv.Interface().(map[int8]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Uint64V(rv2i(rv).(map[int8]uint64), e)
 }
-func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12556,43 +11070,36 @@ func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapInt8UintptrV(rv.Interface().(map[int8]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), e)
 }
-func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12602,43 +11109,36 @@ func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8IntR(rv reflect.Value) {
-	fastpathTV.EncMapInt8IntV(rv.Interface().(map[int8]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8IntV(rv2i(rv).(map[int8]int), e)
 }
-func (_ fastpathT) EncMapInt8IntV(v map[int8]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8IntV(v map[int8]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12648,43 +11148,36 @@ func (_ fastpathT) EncMapInt8IntV(v map[int8]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Int8R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Int8V(rv.Interface().(map[int8]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Int8V(rv2i(rv).(map[int8]int8), e)
 }
-func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12694,43 +11187,36 @@ func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Int16R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Int16V(rv.Interface().(map[int8]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Int16V(rv2i(rv).(map[int8]int16), e)
 }
-func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12740,43 +11226,36 @@ func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Int32R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Int32V(rv.Interface().(map[int8]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Int32V(rv2i(rv).(map[int8]int32), e)
 }
-func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12786,43 +11265,36 @@ func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Int64R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Int64V(rv.Interface().(map[int8]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Int64V(rv2i(rv).(map[int8]int64), e)
 }
-func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12832,43 +11304,36 @@ func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Float32R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Float32V(rv.Interface().(map[int8]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Float32V(rv2i(rv).(map[int8]float32), e)
 }
-func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12878,43 +11343,36 @@ func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Float64R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Float64V(rv.Interface().(map[int8]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Float64V(rv2i(rv).(map[int8]float64), e)
 }
-func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12924,43 +11382,36 @@ func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8BoolR(rv reflect.Value) {
-	fastpathTV.EncMapInt8BoolV(rv.Interface().(map[int8]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8BoolV(rv2i(rv).(map[int8]bool), e)
 }
-func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12970,43 +11421,36 @@ func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16IntfR(rv reflect.Value) {
-	fastpathTV.EncMapInt16IntfV(rv.Interface().(map[int16]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16IntfV(rv2i(rv).(map[int16]interface{}), e)
 }
-func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13016,43 +11460,36 @@ func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, checkNil bool, e *E
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16StringR(rv reflect.Value) {
-	fastpathTV.EncMapInt16StringV(rv.Interface().(map[int16]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16StringV(rv2i(rv).(map[int16]string), e)
 }
-func (_ fastpathT) EncMapInt16StringV(v map[int16]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16StringV(v map[int16]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13062,43 +11499,36 @@ func (_ fastpathT) EncMapInt16StringV(v map[int16]string, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16UintR(rv reflect.Value) {
-	fastpathTV.EncMapInt16UintV(rv.Interface().(map[int16]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16UintV(rv2i(rv).(map[int16]uint), e)
 }
-func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13108,43 +11538,36 @@ func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Uint8V(rv.Interface().(map[int16]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Uint8V(rv2i(rv).(map[int16]uint8), e)
 }
-func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13154,43 +11577,36 @@ func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Uint16V(rv.Interface().(map[int16]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Uint16V(rv2i(rv).(map[int16]uint16), e)
 }
-func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13200,43 +11616,36 @@ func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Uint32V(rv.Interface().(map[int16]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Uint32V(rv2i(rv).(map[int16]uint32), e)
 }
-func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13246,43 +11655,36 @@ func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Uint64V(rv.Interface().(map[int16]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Uint64V(rv2i(rv).(map[int16]uint64), e)
 }
-func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13292,43 +11694,36 @@ func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapInt16UintptrV(rv.Interface().(map[int16]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), e)
 }
-func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13338,43 +11733,36 @@ func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16IntR(rv reflect.Value) {
-	fastpathTV.EncMapInt16IntV(rv.Interface().(map[int16]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16IntV(rv2i(rv).(map[int16]int), e)
 }
-func (_ fastpathT) EncMapInt16IntV(v map[int16]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16IntV(v map[int16]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13384,43 +11772,36 @@ func (_ fastpathT) EncMapInt16IntV(v map[int16]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Int8R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Int8V(rv.Interface().(map[int16]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Int8V(rv2i(rv).(map[int16]int8), e)
 }
-func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13430,43 +11811,36 @@ func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Int16R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Int16V(rv.Interface().(map[int16]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Int16V(rv2i(rv).(map[int16]int16), e)
 }
-func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13476,43 +11850,36 @@ func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Int32R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Int32V(rv.Interface().(map[int16]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Int32V(rv2i(rv).(map[int16]int32), e)
 }
-func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13522,43 +11889,36 @@ func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Int64R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Int64V(rv.Interface().(map[int16]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Int64V(rv2i(rv).(map[int16]int64), e)
 }
-func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13568,43 +11928,36 @@ func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Float32R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Float32V(rv.Interface().(map[int16]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Float32V(rv2i(rv).(map[int16]float32), e)
 }
-func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13614,43 +11967,36 @@ func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Float64R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Float64V(rv.Interface().(map[int16]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Float64V(rv2i(rv).(map[int16]float64), e)
 }
-func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13660,43 +12006,36 @@ func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16BoolR(rv reflect.Value) {
-	fastpathTV.EncMapInt16BoolV(rv.Interface().(map[int16]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16BoolV(rv2i(rv).(map[int16]bool), e)
 }
-func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13706,43 +12045,36 @@ func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32IntfR(rv reflect.Value) {
-	fastpathTV.EncMapInt32IntfV(rv.Interface().(map[int32]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32IntfV(rv2i(rv).(map[int32]interface{}), e)
 }
-func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13752,43 +12084,36 @@ func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, checkNil bool, e *E
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32StringR(rv reflect.Value) {
-	fastpathTV.EncMapInt32StringV(rv.Interface().(map[int32]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32StringV(rv2i(rv).(map[int32]string), e)
 }
-func (_ fastpathT) EncMapInt32StringV(v map[int32]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32StringV(v map[int32]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13798,43 +12123,36 @@ func (_ fastpathT) EncMapInt32StringV(v map[int32]string, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32UintR(rv reflect.Value) {
-	fastpathTV.EncMapInt32UintV(rv.Interface().(map[int32]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32UintV(rv2i(rv).(map[int32]uint), e)
 }
-func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13844,43 +12162,36 @@ func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Uint8V(rv.Interface().(map[int32]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Uint8V(rv2i(rv).(map[int32]uint8), e)
 }
-func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13890,43 +12201,36 @@ func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Uint16V(rv.Interface().(map[int32]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Uint16V(rv2i(rv).(map[int32]uint16), e)
 }
-func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13936,43 +12240,36 @@ func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Uint32V(rv.Interface().(map[int32]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Uint32V(rv2i(rv).(map[int32]uint32), e)
 }
-func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13982,43 +12279,36 @@ func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Uint64V(rv.Interface().(map[int32]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Uint64V(rv2i(rv).(map[int32]uint64), e)
 }
-func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14028,43 +12318,36 @@ func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapInt32UintptrV(rv.Interface().(map[int32]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), e)
 }
-func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14074,43 +12357,36 @@ func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32IntR(rv reflect.Value) {
-	fastpathTV.EncMapInt32IntV(rv.Interface().(map[int32]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32IntV(rv2i(rv).(map[int32]int), e)
 }
-func (_ fastpathT) EncMapInt32IntV(v map[int32]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32IntV(v map[int32]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14120,43 +12396,36 @@ func (_ fastpathT) EncMapInt32IntV(v map[int32]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Int8R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Int8V(rv.Interface().(map[int32]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Int8V(rv2i(rv).(map[int32]int8), e)
 }
-func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14166,43 +12435,36 @@ func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Int16R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Int16V(rv.Interface().(map[int32]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Int16V(rv2i(rv).(map[int32]int16), e)
 }
-func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14212,43 +12474,36 @@ func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Int32R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Int32V(rv.Interface().(map[int32]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Int32V(rv2i(rv).(map[int32]int32), e)
 }
-func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14258,43 +12513,36 @@ func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Int64R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Int64V(rv.Interface().(map[int32]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Int64V(rv2i(rv).(map[int32]int64), e)
 }
-func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14304,43 +12552,36 @@ func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Float32R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Float32V(rv.Interface().(map[int32]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Float32V(rv2i(rv).(map[int32]float32), e)
 }
-func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14350,43 +12591,36 @@ func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Float64R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Float64V(rv.Interface().(map[int32]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Float64V(rv2i(rv).(map[int32]float64), e)
 }
-func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14396,43 +12630,36 @@ func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32BoolR(rv reflect.Value) {
-	fastpathTV.EncMapInt32BoolV(rv.Interface().(map[int32]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32BoolV(rv2i(rv).(map[int32]bool), e)
 }
-func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14442,43 +12669,36 @@ func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64IntfR(rv reflect.Value) {
-	fastpathTV.EncMapInt64IntfV(rv.Interface().(map[int64]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64IntfV(rv2i(rv).(map[int64]interface{}), e)
 }
-func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14488,43 +12708,36 @@ func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, checkNil bool, e *E
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64StringR(rv reflect.Value) {
-	fastpathTV.EncMapInt64StringV(rv.Interface().(map[int64]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64StringV(rv2i(rv).(map[int64]string), e)
 }
-func (_ fastpathT) EncMapInt64StringV(v map[int64]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64StringV(v map[int64]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14534,43 +12747,36 @@ func (_ fastpathT) EncMapInt64StringV(v map[int64]string, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64UintR(rv reflect.Value) {
-	fastpathTV.EncMapInt64UintV(rv.Interface().(map[int64]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64UintV(rv2i(rv).(map[int64]uint), e)
 }
-func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14580,43 +12786,36 @@ func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Uint8V(rv.Interface().(map[int64]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Uint8V(rv2i(rv).(map[int64]uint8), e)
 }
-func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14626,43 +12825,36 @@ func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Uint16V(rv.Interface().(map[int64]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Uint16V(rv2i(rv).(map[int64]uint16), e)
 }
-func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14672,43 +12864,36 @@ func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Uint32V(rv.Interface().(map[int64]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Uint32V(rv2i(rv).(map[int64]uint32), e)
 }
-func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14718,43 +12903,36 @@ func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Uint64V(rv.Interface().(map[int64]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Uint64V(rv2i(rv).(map[int64]uint64), e)
 }
-func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14764,43 +12942,36 @@ func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapInt64UintptrV(rv.Interface().(map[int64]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), e)
 }
-func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14810,43 +12981,36 @@ func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64IntR(rv reflect.Value) {
-	fastpathTV.EncMapInt64IntV(rv.Interface().(map[int64]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64IntV(rv2i(rv).(map[int64]int), e)
 }
-func (_ fastpathT) EncMapInt64IntV(v map[int64]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64IntV(v map[int64]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14856,43 +13020,36 @@ func (_ fastpathT) EncMapInt64IntV(v map[int64]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Int8R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Int8V(rv.Interface().(map[int64]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Int8V(rv2i(rv).(map[int64]int8), e)
 }
-func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14902,43 +13059,36 @@ func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Int16R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Int16V(rv.Interface().(map[int64]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Int16V(rv2i(rv).(map[int64]int16), e)
 }
-func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14948,43 +13098,36 @@ func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Int32R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Int32V(rv.Interface().(map[int64]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Int32V(rv2i(rv).(map[int64]int32), e)
 }
-func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14994,43 +13137,36 @@ func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Int64R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Int64V(rv.Interface().(map[int64]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Int64V(rv2i(rv).(map[int64]int64), e)
 }
-func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15040,43 +13176,36 @@ func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Float32R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Float32V(rv.Interface().(map[int64]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Float32V(rv2i(rv).(map[int64]float32), e)
 }
-func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15086,43 +13215,36 @@ func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Float64R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Float64V(rv.Interface().(map[int64]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Float64V(rv2i(rv).(map[int64]float64), e)
 }
-func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15132,43 +13254,36 @@ func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64BoolR(rv reflect.Value) {
-	fastpathTV.EncMapInt64BoolV(rv.Interface().(map[int64]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64BoolV(rv2i(rv).(map[int64]bool), e)
 }
-func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15178,43 +13293,36 @@ func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolIntfR(rv reflect.Value) {
-	fastpathTV.EncMapBoolIntfV(rv.Interface().(map[bool]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolIntfV(rv2i(rv).(map[bool]interface{}), e)
 }
-func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15224,43 +13332,36 @@ func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, checkNil bool, e *Enc
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolStringR(rv reflect.Value) {
-	fastpathTV.EncMapBoolStringV(rv.Interface().(map[bool]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolStringV(rv2i(rv).(map[bool]string), e)
 }
-func (_ fastpathT) EncMapBoolStringV(v map[bool]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolStringV(v map[bool]string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15270,43 +13371,36 @@ func (_ fastpathT) EncMapBoolStringV(v map[bool]string, checkNil bool, e *Encode
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeString(c_UTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUintR(rv reflect.Value) {
-	fastpathTV.EncMapBoolUintV(rv.Interface().(map[bool]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUintV(rv2i(rv).(map[bool]uint), e)
 }
-func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15316,43 +13410,36 @@ func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUint8R(rv reflect.Value) {
-	fastpathTV.EncMapBoolUint8V(rv.Interface().(map[bool]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUint8V(rv2i(rv).(map[bool]uint8), e)
 }
-func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15362,43 +13449,36 @@ func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUint16R(rv reflect.Value) {
-	fastpathTV.EncMapBoolUint16V(rv.Interface().(map[bool]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUint16V(rv2i(rv).(map[bool]uint16), e)
 }
-func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15408,43 +13488,36 @@ func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, checkNil bool, e *Encode
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUint32R(rv reflect.Value) {
-	fastpathTV.EncMapBoolUint32V(rv.Interface().(map[bool]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUint32V(rv2i(rv).(map[bool]uint32), e)
 }
-func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15454,43 +13527,36 @@ func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, checkNil bool, e *Encode
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUint64R(rv reflect.Value) {
-	fastpathTV.EncMapBoolUint64V(rv.Interface().(map[bool]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUint64V(rv2i(rv).(map[bool]uint64), e)
 }
-func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15500,43 +13566,36 @@ func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, checkNil bool, e *Encode
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapBoolUintptrV(rv.Interface().(map[bool]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), e)
 }
-func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15546,43 +13605,36 @@ func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, checkNil bool, e *Enco
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolIntR(rv reflect.Value) {
-	fastpathTV.EncMapBoolIntV(rv.Interface().(map[bool]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolIntV(rv2i(rv).(map[bool]int), e)
 }
-func (_ fastpathT) EncMapBoolIntV(v map[bool]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolIntV(v map[bool]int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15592,43 +13644,36 @@ func (_ fastpathT) EncMapBoolIntV(v map[bool]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolInt8R(rv reflect.Value) {
-	fastpathTV.EncMapBoolInt8V(rv.Interface().(map[bool]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolInt8V(rv2i(rv).(map[bool]int8), e)
 }
-func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15638,43 +13683,36 @@ func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolInt16R(rv reflect.Value) {
-	fastpathTV.EncMapBoolInt16V(rv.Interface().(map[bool]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolInt16V(rv2i(rv).(map[bool]int16), e)
 }
-func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15684,43 +13722,36 @@ func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, checkNil bool, e *Encoder)
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolInt32R(rv reflect.Value) {
-	fastpathTV.EncMapBoolInt32V(rv.Interface().(map[bool]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolInt32V(rv2i(rv).(map[bool]int32), e)
 }
-func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15730,43 +13761,36 @@ func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, checkNil bool, e *Encoder)
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolInt64R(rv reflect.Value) {
-	fastpathTV.EncMapBoolInt64V(rv.Interface().(map[bool]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolInt64V(rv2i(rv).(map[bool]int64), e)
 }
-func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15776,43 +13800,36 @@ func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, checkNil bool, e *Encoder)
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapBoolFloat32V(rv.Interface().(map[bool]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolFloat32V(rv2i(rv).(map[bool]float32), e)
 }
-func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15822,43 +13839,36 @@ func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, checkNil bool, e *Enco
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapBoolFloat64V(rv.Interface().(map[bool]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolFloat64V(rv2i(rv).(map[bool]float64), e)
 }
-func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15868,43 +13878,36 @@ func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, checkNil bool, e *Enco
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolBoolR(rv reflect.Value) {
-	fastpathTV.EncMapBoolBoolV(rv.Interface().(map[bool]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolBoolV(rv2i(rv).(map[bool]bool), e)
 }
-func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15914,30 +13917,28 @@ func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
 // -- decode
@@ -15947,2170 +13948,1899 @@ func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
 	switch v := iv.(type) {
 
 	case []interface{}:
-		fastpathTV.DecSliceIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceIntfV(v, false, d)
 	case *[]interface{}:
-		v2, changed2 := fastpathTV.DecSliceIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceIntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]interface{}:
-		fastpathTV.DecMapIntfIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfIntfV(v, false, d)
 	case *map[interface{}]interface{}:
-		v2, changed2 := fastpathTV.DecMapIntfIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfIntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]string:
-		fastpathTV.DecMapIntfStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfStringV(v, false, d)
 	case *map[interface{}]string:
-		v2, changed2 := fastpathTV.DecMapIntfStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfStringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]uint:
-		fastpathTV.DecMapIntfUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUintV(v, false, d)
 	case *map[interface{}]uint:
-		v2, changed2 := fastpathTV.DecMapIntfUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfUintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]uint8:
-		fastpathTV.DecMapIntfUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUint8V(v, false, d)
 	case *map[interface{}]uint8:
-		v2, changed2 := fastpathTV.DecMapIntfUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfUint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]uint16:
-		fastpathTV.DecMapIntfUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUint16V(v, false, d)
 	case *map[interface{}]uint16:
-		v2, changed2 := fastpathTV.DecMapIntfUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfUint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]uint32:
-		fastpathTV.DecMapIntfUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUint32V(v, false, d)
 	case *map[interface{}]uint32:
-		v2, changed2 := fastpathTV.DecMapIntfUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfUint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]uint64:
-		fastpathTV.DecMapIntfUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUint64V(v, false, d)
 	case *map[interface{}]uint64:
-		v2, changed2 := fastpathTV.DecMapIntfUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfUint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]uintptr:
-		fastpathTV.DecMapIntfUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUintptrV(v, false, d)
 	case *map[interface{}]uintptr:
-		v2, changed2 := fastpathTV.DecMapIntfUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfUintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]int:
-		fastpathTV.DecMapIntfIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfIntV(v, false, d)
 	case *map[interface{}]int:
-		v2, changed2 := fastpathTV.DecMapIntfIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfIntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]int8:
-		fastpathTV.DecMapIntfInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfInt8V(v, false, d)
 	case *map[interface{}]int8:
-		v2, changed2 := fastpathTV.DecMapIntfInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfInt8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]int16:
-		fastpathTV.DecMapIntfInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfInt16V(v, false, d)
 	case *map[interface{}]int16:
-		v2, changed2 := fastpathTV.DecMapIntfInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfInt16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]int32:
-		fastpathTV.DecMapIntfInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfInt32V(v, false, d)
 	case *map[interface{}]int32:
-		v2, changed2 := fastpathTV.DecMapIntfInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfInt32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]int64:
-		fastpathTV.DecMapIntfInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfInt64V(v, false, d)
 	case *map[interface{}]int64:
-		v2, changed2 := fastpathTV.DecMapIntfInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfInt64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]float32:
-		fastpathTV.DecMapIntfFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfFloat32V(v, false, d)
 	case *map[interface{}]float32:
-		v2, changed2 := fastpathTV.DecMapIntfFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfFloat32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]float64:
-		fastpathTV.DecMapIntfFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfFloat64V(v, false, d)
 	case *map[interface{}]float64:
-		v2, changed2 := fastpathTV.DecMapIntfFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfFloat64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[interface{}]bool:
-		fastpathTV.DecMapIntfBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfBoolV(v, false, d)
 	case *map[interface{}]bool:
-		v2, changed2 := fastpathTV.DecMapIntfBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntfBoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []string:
-		fastpathTV.DecSliceStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceStringV(v, false, d)
 	case *[]string:
-		v2, changed2 := fastpathTV.DecSliceStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceStringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]interface{}:
-		fastpathTV.DecMapStringIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringIntfV(v, false, d)
 	case *map[string]interface{}:
-		v2, changed2 := fastpathTV.DecMapStringIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringIntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]string:
-		fastpathTV.DecMapStringStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringStringV(v, false, d)
 	case *map[string]string:
-		v2, changed2 := fastpathTV.DecMapStringStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringStringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]uint:
-		fastpathTV.DecMapStringUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUintV(v, false, d)
 	case *map[string]uint:
-		v2, changed2 := fastpathTV.DecMapStringUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringUintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]uint8:
-		fastpathTV.DecMapStringUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUint8V(v, false, d)
 	case *map[string]uint8:
-		v2, changed2 := fastpathTV.DecMapStringUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringUint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]uint16:
-		fastpathTV.DecMapStringUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUint16V(v, false, d)
 	case *map[string]uint16:
-		v2, changed2 := fastpathTV.DecMapStringUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringUint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]uint32:
-		fastpathTV.DecMapStringUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUint32V(v, false, d)
 	case *map[string]uint32:
-		v2, changed2 := fastpathTV.DecMapStringUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringUint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]uint64:
-		fastpathTV.DecMapStringUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUint64V(v, false, d)
 	case *map[string]uint64:
-		v2, changed2 := fastpathTV.DecMapStringUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringUint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]uintptr:
-		fastpathTV.DecMapStringUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUintptrV(v, false, d)
 	case *map[string]uintptr:
-		v2, changed2 := fastpathTV.DecMapStringUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringUintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]int:
-		fastpathTV.DecMapStringIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringIntV(v, false, d)
 	case *map[string]int:
-		v2, changed2 := fastpathTV.DecMapStringIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringIntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]int8:
-		fastpathTV.DecMapStringInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringInt8V(v, false, d)
 	case *map[string]int8:
-		v2, changed2 := fastpathTV.DecMapStringInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringInt8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]int16:
-		fastpathTV.DecMapStringInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringInt16V(v, false, d)
 	case *map[string]int16:
-		v2, changed2 := fastpathTV.DecMapStringInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringInt16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]int32:
-		fastpathTV.DecMapStringInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringInt32V(v, false, d)
 	case *map[string]int32:
-		v2, changed2 := fastpathTV.DecMapStringInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringInt32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]int64:
-		fastpathTV.DecMapStringInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringInt64V(v, false, d)
 	case *map[string]int64:
-		v2, changed2 := fastpathTV.DecMapStringInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringInt64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]float32:
-		fastpathTV.DecMapStringFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringFloat32V(v, false, d)
 	case *map[string]float32:
-		v2, changed2 := fastpathTV.DecMapStringFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringFloat32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]float64:
-		fastpathTV.DecMapStringFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringFloat64V(v, false, d)
 	case *map[string]float64:
-		v2, changed2 := fastpathTV.DecMapStringFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringFloat64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[string]bool:
-		fastpathTV.DecMapStringBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringBoolV(v, false, d)
 	case *map[string]bool:
-		v2, changed2 := fastpathTV.DecMapStringBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapStringBoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []float32:
-		fastpathTV.DecSliceFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceFloat32V(v, false, d)
 	case *[]float32:
-		v2, changed2 := fastpathTV.DecSliceFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceFloat32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]interface{}:
-		fastpathTV.DecMapFloat32IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32IntfV(v, false, d)
 	case *map[float32]interface{}:
-		v2, changed2 := fastpathTV.DecMapFloat32IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32IntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]string:
-		fastpathTV.DecMapFloat32StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32StringV(v, false, d)
 	case *map[float32]string:
-		v2, changed2 := fastpathTV.DecMapFloat32StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32StringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]uint:
-		fastpathTV.DecMapFloat32UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32UintV(v, false, d)
 	case *map[float32]uint:
-		v2, changed2 := fastpathTV.DecMapFloat32UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32UintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]uint8:
-		fastpathTV.DecMapFloat32Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Uint8V(v, false, d)
 	case *map[float32]uint8:
-		v2, changed2 := fastpathTV.DecMapFloat32Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32Uint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]uint16:
-		fastpathTV.DecMapFloat32Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Uint16V(v, false, d)
 	case *map[float32]uint16:
-		v2, changed2 := fastpathTV.DecMapFloat32Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32Uint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]uint32:
-		fastpathTV.DecMapFloat32Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Uint32V(v, false, d)
 	case *map[float32]uint32:
-		v2, changed2 := fastpathTV.DecMapFloat32Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32Uint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]uint64:
-		fastpathTV.DecMapFloat32Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Uint64V(v, false, d)
 	case *map[float32]uint64:
-		v2, changed2 := fastpathTV.DecMapFloat32Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32Uint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]uintptr:
-		fastpathTV.DecMapFloat32UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32UintptrV(v, false, d)
 	case *map[float32]uintptr:
-		v2, changed2 := fastpathTV.DecMapFloat32UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32UintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]int:
-		fastpathTV.DecMapFloat32IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32IntV(v, false, d)
 	case *map[float32]int:
-		v2, changed2 := fastpathTV.DecMapFloat32IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32IntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]int8:
-		fastpathTV.DecMapFloat32Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Int8V(v, false, d)
 	case *map[float32]int8:
-		v2, changed2 := fastpathTV.DecMapFloat32Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32Int8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]int16:
-		fastpathTV.DecMapFloat32Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Int16V(v, false, d)
 	case *map[float32]int16:
-		v2, changed2 := fastpathTV.DecMapFloat32Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32Int16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]int32:
-		fastpathTV.DecMapFloat32Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Int32V(v, false, d)
 	case *map[float32]int32:
-		v2, changed2 := fastpathTV.DecMapFloat32Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32Int32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]int64:
-		fastpathTV.DecMapFloat32Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Int64V(v, false, d)
 	case *map[float32]int64:
-		v2, changed2 := fastpathTV.DecMapFloat32Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32Int64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]float32:
-		fastpathTV.DecMapFloat32Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Float32V(v, false, d)
 	case *map[float32]float32:
-		v2, changed2 := fastpathTV.DecMapFloat32Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32Float32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]float64:
-		fastpathTV.DecMapFloat32Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Float64V(v, false, d)
 	case *map[float32]float64:
-		v2, changed2 := fastpathTV.DecMapFloat32Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32Float64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float32]bool:
-		fastpathTV.DecMapFloat32BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32BoolV(v, false, d)
 	case *map[float32]bool:
-		v2, changed2 := fastpathTV.DecMapFloat32BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat32BoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []float64:
-		fastpathTV.DecSliceFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceFloat64V(v, false, d)
 	case *[]float64:
-		v2, changed2 := fastpathTV.DecSliceFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceFloat64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]interface{}:
-		fastpathTV.DecMapFloat64IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64IntfV(v, false, d)
 	case *map[float64]interface{}:
-		v2, changed2 := fastpathTV.DecMapFloat64IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64IntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]string:
-		fastpathTV.DecMapFloat64StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64StringV(v, false, d)
 	case *map[float64]string:
-		v2, changed2 := fastpathTV.DecMapFloat64StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64StringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]uint:
-		fastpathTV.DecMapFloat64UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64UintV(v, false, d)
 	case *map[float64]uint:
-		v2, changed2 := fastpathTV.DecMapFloat64UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64UintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]uint8:
-		fastpathTV.DecMapFloat64Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Uint8V(v, false, d)
 	case *map[float64]uint8:
-		v2, changed2 := fastpathTV.DecMapFloat64Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64Uint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]uint16:
-		fastpathTV.DecMapFloat64Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Uint16V(v, false, d)
 	case *map[float64]uint16:
-		v2, changed2 := fastpathTV.DecMapFloat64Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64Uint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]uint32:
-		fastpathTV.DecMapFloat64Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Uint32V(v, false, d)
 	case *map[float64]uint32:
-		v2, changed2 := fastpathTV.DecMapFloat64Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64Uint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]uint64:
-		fastpathTV.DecMapFloat64Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Uint64V(v, false, d)
 	case *map[float64]uint64:
-		v2, changed2 := fastpathTV.DecMapFloat64Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64Uint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]uintptr:
-		fastpathTV.DecMapFloat64UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64UintptrV(v, false, d)
 	case *map[float64]uintptr:
-		v2, changed2 := fastpathTV.DecMapFloat64UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64UintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]int:
-		fastpathTV.DecMapFloat64IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64IntV(v, false, d)
 	case *map[float64]int:
-		v2, changed2 := fastpathTV.DecMapFloat64IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64IntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]int8:
-		fastpathTV.DecMapFloat64Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Int8V(v, false, d)
 	case *map[float64]int8:
-		v2, changed2 := fastpathTV.DecMapFloat64Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64Int8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]int16:
-		fastpathTV.DecMapFloat64Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Int16V(v, false, d)
 	case *map[float64]int16:
-		v2, changed2 := fastpathTV.DecMapFloat64Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64Int16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]int32:
-		fastpathTV.DecMapFloat64Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Int32V(v, false, d)
 	case *map[float64]int32:
-		v2, changed2 := fastpathTV.DecMapFloat64Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64Int32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]int64:
-		fastpathTV.DecMapFloat64Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Int64V(v, false, d)
 	case *map[float64]int64:
-		v2, changed2 := fastpathTV.DecMapFloat64Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64Int64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]float32:
-		fastpathTV.DecMapFloat64Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Float32V(v, false, d)
 	case *map[float64]float32:
-		v2, changed2 := fastpathTV.DecMapFloat64Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64Float32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]float64:
-		fastpathTV.DecMapFloat64Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Float64V(v, false, d)
 	case *map[float64]float64:
-		v2, changed2 := fastpathTV.DecMapFloat64Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64Float64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[float64]bool:
-		fastpathTV.DecMapFloat64BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64BoolV(v, false, d)
 	case *map[float64]bool:
-		v2, changed2 := fastpathTV.DecMapFloat64BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapFloat64BoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []uint:
-		fastpathTV.DecSliceUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceUintV(v, false, d)
 	case *[]uint:
-		v2, changed2 := fastpathTV.DecSliceUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceUintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]interface{}:
-		fastpathTV.DecMapUintIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintIntfV(v, false, d)
 	case *map[uint]interface{}:
-		v2, changed2 := fastpathTV.DecMapUintIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintIntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]string:
-		fastpathTV.DecMapUintStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintStringV(v, false, d)
 	case *map[uint]string:
-		v2, changed2 := fastpathTV.DecMapUintStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintStringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]uint:
-		fastpathTV.DecMapUintUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUintV(v, false, d)
 	case *map[uint]uint:
-		v2, changed2 := fastpathTV.DecMapUintUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintUintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]uint8:
-		fastpathTV.DecMapUintUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUint8V(v, false, d)
 	case *map[uint]uint8:
-		v2, changed2 := fastpathTV.DecMapUintUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintUint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]uint16:
-		fastpathTV.DecMapUintUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUint16V(v, false, d)
 	case *map[uint]uint16:
-		v2, changed2 := fastpathTV.DecMapUintUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintUint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]uint32:
-		fastpathTV.DecMapUintUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUint32V(v, false, d)
 	case *map[uint]uint32:
-		v2, changed2 := fastpathTV.DecMapUintUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintUint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]uint64:
-		fastpathTV.DecMapUintUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUint64V(v, false, d)
 	case *map[uint]uint64:
-		v2, changed2 := fastpathTV.DecMapUintUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintUint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]uintptr:
-		fastpathTV.DecMapUintUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUintptrV(v, false, d)
 	case *map[uint]uintptr:
-		v2, changed2 := fastpathTV.DecMapUintUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintUintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]int:
-		fastpathTV.DecMapUintIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintIntV(v, false, d)
 	case *map[uint]int:
-		v2, changed2 := fastpathTV.DecMapUintIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintIntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]int8:
-		fastpathTV.DecMapUintInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintInt8V(v, false, d)
 	case *map[uint]int8:
-		v2, changed2 := fastpathTV.DecMapUintInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintInt8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]int16:
-		fastpathTV.DecMapUintInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintInt16V(v, false, d)
 	case *map[uint]int16:
-		v2, changed2 := fastpathTV.DecMapUintInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintInt16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]int32:
-		fastpathTV.DecMapUintInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintInt32V(v, false, d)
 	case *map[uint]int32:
-		v2, changed2 := fastpathTV.DecMapUintInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintInt32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]int64:
-		fastpathTV.DecMapUintInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintInt64V(v, false, d)
 	case *map[uint]int64:
-		v2, changed2 := fastpathTV.DecMapUintInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintInt64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]float32:
-		fastpathTV.DecMapUintFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintFloat32V(v, false, d)
 	case *map[uint]float32:
-		v2, changed2 := fastpathTV.DecMapUintFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintFloat32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]float64:
-		fastpathTV.DecMapUintFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintFloat64V(v, false, d)
 	case *map[uint]float64:
-		v2, changed2 := fastpathTV.DecMapUintFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintFloat64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint]bool:
-		fastpathTV.DecMapUintBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintBoolV(v, false, d)
 	case *map[uint]bool:
-		v2, changed2 := fastpathTV.DecMapUintBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintBoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]interface{}:
-		fastpathTV.DecMapUint8IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8IntfV(v, false, d)
 	case *map[uint8]interface{}:
-		v2, changed2 := fastpathTV.DecMapUint8IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8IntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]string:
-		fastpathTV.DecMapUint8StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8StringV(v, false, d)
 	case *map[uint8]string:
-		v2, changed2 := fastpathTV.DecMapUint8StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8StringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]uint:
-		fastpathTV.DecMapUint8UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8UintV(v, false, d)
 	case *map[uint8]uint:
-		v2, changed2 := fastpathTV.DecMapUint8UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8UintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]uint8:
-		fastpathTV.DecMapUint8Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Uint8V(v, false, d)
 	case *map[uint8]uint8:
-		v2, changed2 := fastpathTV.DecMapUint8Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8Uint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]uint16:
-		fastpathTV.DecMapUint8Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Uint16V(v, false, d)
 	case *map[uint8]uint16:
-		v2, changed2 := fastpathTV.DecMapUint8Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8Uint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]uint32:
-		fastpathTV.DecMapUint8Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Uint32V(v, false, d)
 	case *map[uint8]uint32:
-		v2, changed2 := fastpathTV.DecMapUint8Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8Uint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]uint64:
-		fastpathTV.DecMapUint8Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Uint64V(v, false, d)
 	case *map[uint8]uint64:
-		v2, changed2 := fastpathTV.DecMapUint8Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8Uint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]uintptr:
-		fastpathTV.DecMapUint8UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8UintptrV(v, false, d)
 	case *map[uint8]uintptr:
-		v2, changed2 := fastpathTV.DecMapUint8UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8UintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]int:
-		fastpathTV.DecMapUint8IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8IntV(v, false, d)
 	case *map[uint8]int:
-		v2, changed2 := fastpathTV.DecMapUint8IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8IntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]int8:
-		fastpathTV.DecMapUint8Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Int8V(v, false, d)
 	case *map[uint8]int8:
-		v2, changed2 := fastpathTV.DecMapUint8Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8Int8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]int16:
-		fastpathTV.DecMapUint8Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Int16V(v, false, d)
 	case *map[uint8]int16:
-		v2, changed2 := fastpathTV.DecMapUint8Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8Int16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]int32:
-		fastpathTV.DecMapUint8Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Int32V(v, false, d)
 	case *map[uint8]int32:
-		v2, changed2 := fastpathTV.DecMapUint8Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8Int32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]int64:
-		fastpathTV.DecMapUint8Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Int64V(v, false, d)
 	case *map[uint8]int64:
-		v2, changed2 := fastpathTV.DecMapUint8Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8Int64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]float32:
-		fastpathTV.DecMapUint8Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Float32V(v, false, d)
 	case *map[uint8]float32:
-		v2, changed2 := fastpathTV.DecMapUint8Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8Float32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]float64:
-		fastpathTV.DecMapUint8Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Float64V(v, false, d)
 	case *map[uint8]float64:
-		v2, changed2 := fastpathTV.DecMapUint8Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8Float64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint8]bool:
-		fastpathTV.DecMapUint8BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8BoolV(v, false, d)
 	case *map[uint8]bool:
-		v2, changed2 := fastpathTV.DecMapUint8BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint8BoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []uint16:
-		fastpathTV.DecSliceUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceUint16V(v, false, d)
 	case *[]uint16:
-		v2, changed2 := fastpathTV.DecSliceUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceUint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]interface{}:
-		fastpathTV.DecMapUint16IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16IntfV(v, false, d)
 	case *map[uint16]interface{}:
-		v2, changed2 := fastpathTV.DecMapUint16IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16IntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]string:
-		fastpathTV.DecMapUint16StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16StringV(v, false, d)
 	case *map[uint16]string:
-		v2, changed2 := fastpathTV.DecMapUint16StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16StringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]uint:
-		fastpathTV.DecMapUint16UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16UintV(v, false, d)
 	case *map[uint16]uint:
-		v2, changed2 := fastpathTV.DecMapUint16UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16UintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]uint8:
-		fastpathTV.DecMapUint16Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Uint8V(v, false, d)
 	case *map[uint16]uint8:
-		v2, changed2 := fastpathTV.DecMapUint16Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16Uint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]uint16:
-		fastpathTV.DecMapUint16Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Uint16V(v, false, d)
 	case *map[uint16]uint16:
-		v2, changed2 := fastpathTV.DecMapUint16Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16Uint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]uint32:
-		fastpathTV.DecMapUint16Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Uint32V(v, false, d)
 	case *map[uint16]uint32:
-		v2, changed2 := fastpathTV.DecMapUint16Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16Uint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]uint64:
-		fastpathTV.DecMapUint16Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Uint64V(v, false, d)
 	case *map[uint16]uint64:
-		v2, changed2 := fastpathTV.DecMapUint16Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16Uint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]uintptr:
-		fastpathTV.DecMapUint16UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16UintptrV(v, false, d)
 	case *map[uint16]uintptr:
-		v2, changed2 := fastpathTV.DecMapUint16UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16UintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]int:
-		fastpathTV.DecMapUint16IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16IntV(v, false, d)
 	case *map[uint16]int:
-		v2, changed2 := fastpathTV.DecMapUint16IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16IntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]int8:
-		fastpathTV.DecMapUint16Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Int8V(v, false, d)
 	case *map[uint16]int8:
-		v2, changed2 := fastpathTV.DecMapUint16Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16Int8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]int16:
-		fastpathTV.DecMapUint16Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Int16V(v, false, d)
 	case *map[uint16]int16:
-		v2, changed2 := fastpathTV.DecMapUint16Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16Int16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]int32:
-		fastpathTV.DecMapUint16Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Int32V(v, false, d)
 	case *map[uint16]int32:
-		v2, changed2 := fastpathTV.DecMapUint16Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16Int32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]int64:
-		fastpathTV.DecMapUint16Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Int64V(v, false, d)
 	case *map[uint16]int64:
-		v2, changed2 := fastpathTV.DecMapUint16Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16Int64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]float32:
-		fastpathTV.DecMapUint16Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Float32V(v, false, d)
 	case *map[uint16]float32:
-		v2, changed2 := fastpathTV.DecMapUint16Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16Float32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]float64:
-		fastpathTV.DecMapUint16Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Float64V(v, false, d)
 	case *map[uint16]float64:
-		v2, changed2 := fastpathTV.DecMapUint16Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16Float64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint16]bool:
-		fastpathTV.DecMapUint16BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16BoolV(v, false, d)
 	case *map[uint16]bool:
-		v2, changed2 := fastpathTV.DecMapUint16BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint16BoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []uint32:
-		fastpathTV.DecSliceUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceUint32V(v, false, d)
 	case *[]uint32:
-		v2, changed2 := fastpathTV.DecSliceUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceUint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]interface{}:
-		fastpathTV.DecMapUint32IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32IntfV(v, false, d)
 	case *map[uint32]interface{}:
-		v2, changed2 := fastpathTV.DecMapUint32IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32IntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]string:
-		fastpathTV.DecMapUint32StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32StringV(v, false, d)
 	case *map[uint32]string:
-		v2, changed2 := fastpathTV.DecMapUint32StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32StringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]uint:
-		fastpathTV.DecMapUint32UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32UintV(v, false, d)
 	case *map[uint32]uint:
-		v2, changed2 := fastpathTV.DecMapUint32UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32UintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]uint8:
-		fastpathTV.DecMapUint32Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Uint8V(v, false, d)
 	case *map[uint32]uint8:
-		v2, changed2 := fastpathTV.DecMapUint32Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32Uint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]uint16:
-		fastpathTV.DecMapUint32Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Uint16V(v, false, d)
 	case *map[uint32]uint16:
-		v2, changed2 := fastpathTV.DecMapUint32Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32Uint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]uint32:
-		fastpathTV.DecMapUint32Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Uint32V(v, false, d)
 	case *map[uint32]uint32:
-		v2, changed2 := fastpathTV.DecMapUint32Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32Uint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]uint64:
-		fastpathTV.DecMapUint32Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Uint64V(v, false, d)
 	case *map[uint32]uint64:
-		v2, changed2 := fastpathTV.DecMapUint32Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32Uint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]uintptr:
-		fastpathTV.DecMapUint32UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32UintptrV(v, false, d)
 	case *map[uint32]uintptr:
-		v2, changed2 := fastpathTV.DecMapUint32UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32UintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]int:
-		fastpathTV.DecMapUint32IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32IntV(v, false, d)
 	case *map[uint32]int:
-		v2, changed2 := fastpathTV.DecMapUint32IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32IntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]int8:
-		fastpathTV.DecMapUint32Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Int8V(v, false, d)
 	case *map[uint32]int8:
-		v2, changed2 := fastpathTV.DecMapUint32Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32Int8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]int16:
-		fastpathTV.DecMapUint32Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Int16V(v, false, d)
 	case *map[uint32]int16:
-		v2, changed2 := fastpathTV.DecMapUint32Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32Int16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]int32:
-		fastpathTV.DecMapUint32Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Int32V(v, false, d)
 	case *map[uint32]int32:
-		v2, changed2 := fastpathTV.DecMapUint32Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32Int32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]int64:
-		fastpathTV.DecMapUint32Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Int64V(v, false, d)
 	case *map[uint32]int64:
-		v2, changed2 := fastpathTV.DecMapUint32Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32Int64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]float32:
-		fastpathTV.DecMapUint32Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Float32V(v, false, d)
 	case *map[uint32]float32:
-		v2, changed2 := fastpathTV.DecMapUint32Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32Float32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]float64:
-		fastpathTV.DecMapUint32Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Float64V(v, false, d)
 	case *map[uint32]float64:
-		v2, changed2 := fastpathTV.DecMapUint32Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32Float64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint32]bool:
-		fastpathTV.DecMapUint32BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32BoolV(v, false, d)
 	case *map[uint32]bool:
-		v2, changed2 := fastpathTV.DecMapUint32BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint32BoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []uint64:
-		fastpathTV.DecSliceUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceUint64V(v, false, d)
 	case *[]uint64:
-		v2, changed2 := fastpathTV.DecSliceUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceUint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]interface{}:
-		fastpathTV.DecMapUint64IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64IntfV(v, false, d)
 	case *map[uint64]interface{}:
-		v2, changed2 := fastpathTV.DecMapUint64IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64IntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]string:
-		fastpathTV.DecMapUint64StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64StringV(v, false, d)
 	case *map[uint64]string:
-		v2, changed2 := fastpathTV.DecMapUint64StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64StringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]uint:
-		fastpathTV.DecMapUint64UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64UintV(v, false, d)
 	case *map[uint64]uint:
-		v2, changed2 := fastpathTV.DecMapUint64UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64UintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]uint8:
-		fastpathTV.DecMapUint64Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Uint8V(v, false, d)
 	case *map[uint64]uint8:
-		v2, changed2 := fastpathTV.DecMapUint64Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64Uint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]uint16:
-		fastpathTV.DecMapUint64Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Uint16V(v, false, d)
 	case *map[uint64]uint16:
-		v2, changed2 := fastpathTV.DecMapUint64Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64Uint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]uint32:
-		fastpathTV.DecMapUint64Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Uint32V(v, false, d)
 	case *map[uint64]uint32:
-		v2, changed2 := fastpathTV.DecMapUint64Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64Uint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]uint64:
-		fastpathTV.DecMapUint64Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Uint64V(v, false, d)
 	case *map[uint64]uint64:
-		v2, changed2 := fastpathTV.DecMapUint64Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64Uint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]uintptr:
-		fastpathTV.DecMapUint64UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64UintptrV(v, false, d)
 	case *map[uint64]uintptr:
-		v2, changed2 := fastpathTV.DecMapUint64UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64UintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]int:
-		fastpathTV.DecMapUint64IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64IntV(v, false, d)
 	case *map[uint64]int:
-		v2, changed2 := fastpathTV.DecMapUint64IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64IntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]int8:
-		fastpathTV.DecMapUint64Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Int8V(v, false, d)
 	case *map[uint64]int8:
-		v2, changed2 := fastpathTV.DecMapUint64Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64Int8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]int16:
-		fastpathTV.DecMapUint64Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Int16V(v, false, d)
 	case *map[uint64]int16:
-		v2, changed2 := fastpathTV.DecMapUint64Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64Int16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]int32:
-		fastpathTV.DecMapUint64Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Int32V(v, false, d)
 	case *map[uint64]int32:
-		v2, changed2 := fastpathTV.DecMapUint64Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64Int32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]int64:
-		fastpathTV.DecMapUint64Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Int64V(v, false, d)
 	case *map[uint64]int64:
-		v2, changed2 := fastpathTV.DecMapUint64Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64Int64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]float32:
-		fastpathTV.DecMapUint64Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Float32V(v, false, d)
 	case *map[uint64]float32:
-		v2, changed2 := fastpathTV.DecMapUint64Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64Float32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]float64:
-		fastpathTV.DecMapUint64Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Float64V(v, false, d)
 	case *map[uint64]float64:
-		v2, changed2 := fastpathTV.DecMapUint64Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64Float64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uint64]bool:
-		fastpathTV.DecMapUint64BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64BoolV(v, false, d)
 	case *map[uint64]bool:
-		v2, changed2 := fastpathTV.DecMapUint64BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUint64BoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []uintptr:
-		fastpathTV.DecSliceUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceUintptrV(v, false, d)
 	case *[]uintptr:
-		v2, changed2 := fastpathTV.DecSliceUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceUintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]interface{}:
-		fastpathTV.DecMapUintptrIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrIntfV(v, false, d)
 	case *map[uintptr]interface{}:
-		v2, changed2 := fastpathTV.DecMapUintptrIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrIntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]string:
-		fastpathTV.DecMapUintptrStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrStringV(v, false, d)
 	case *map[uintptr]string:
-		v2, changed2 := fastpathTV.DecMapUintptrStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrStringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]uint:
-		fastpathTV.DecMapUintptrUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUintV(v, false, d)
 	case *map[uintptr]uint:
-		v2, changed2 := fastpathTV.DecMapUintptrUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrUintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]uint8:
-		fastpathTV.DecMapUintptrUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUint8V(v, false, d)
 	case *map[uintptr]uint8:
-		v2, changed2 := fastpathTV.DecMapUintptrUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrUint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]uint16:
-		fastpathTV.DecMapUintptrUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUint16V(v, false, d)
 	case *map[uintptr]uint16:
-		v2, changed2 := fastpathTV.DecMapUintptrUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrUint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]uint32:
-		fastpathTV.DecMapUintptrUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUint32V(v, false, d)
 	case *map[uintptr]uint32:
-		v2, changed2 := fastpathTV.DecMapUintptrUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrUint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]uint64:
-		fastpathTV.DecMapUintptrUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUint64V(v, false, d)
 	case *map[uintptr]uint64:
-		v2, changed2 := fastpathTV.DecMapUintptrUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrUint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]uintptr:
-		fastpathTV.DecMapUintptrUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUintptrV(v, false, d)
 	case *map[uintptr]uintptr:
-		v2, changed2 := fastpathTV.DecMapUintptrUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrUintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]int:
-		fastpathTV.DecMapUintptrIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrIntV(v, false, d)
 	case *map[uintptr]int:
-		v2, changed2 := fastpathTV.DecMapUintptrIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrIntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]int8:
-		fastpathTV.DecMapUintptrInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrInt8V(v, false, d)
 	case *map[uintptr]int8:
-		v2, changed2 := fastpathTV.DecMapUintptrInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrInt8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]int16:
-		fastpathTV.DecMapUintptrInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrInt16V(v, false, d)
 	case *map[uintptr]int16:
-		v2, changed2 := fastpathTV.DecMapUintptrInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrInt16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]int32:
-		fastpathTV.DecMapUintptrInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrInt32V(v, false, d)
 	case *map[uintptr]int32:
-		v2, changed2 := fastpathTV.DecMapUintptrInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrInt32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]int64:
-		fastpathTV.DecMapUintptrInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrInt64V(v, false, d)
 	case *map[uintptr]int64:
-		v2, changed2 := fastpathTV.DecMapUintptrInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrInt64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]float32:
-		fastpathTV.DecMapUintptrFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrFloat32V(v, false, d)
 	case *map[uintptr]float32:
-		v2, changed2 := fastpathTV.DecMapUintptrFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrFloat32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]float64:
-		fastpathTV.DecMapUintptrFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrFloat64V(v, false, d)
 	case *map[uintptr]float64:
-		v2, changed2 := fastpathTV.DecMapUintptrFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrFloat64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[uintptr]bool:
-		fastpathTV.DecMapUintptrBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrBoolV(v, false, d)
 	case *map[uintptr]bool:
-		v2, changed2 := fastpathTV.DecMapUintptrBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapUintptrBoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []int:
-		fastpathTV.DecSliceIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceIntV(v, false, d)
 	case *[]int:
-		v2, changed2 := fastpathTV.DecSliceIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceIntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]interface{}:
-		fastpathTV.DecMapIntIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntIntfV(v, false, d)
 	case *map[int]interface{}:
-		v2, changed2 := fastpathTV.DecMapIntIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntIntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]string:
-		fastpathTV.DecMapIntStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntStringV(v, false, d)
 	case *map[int]string:
-		v2, changed2 := fastpathTV.DecMapIntStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntStringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]uint:
-		fastpathTV.DecMapIntUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUintV(v, false, d)
 	case *map[int]uint:
-		v2, changed2 := fastpathTV.DecMapIntUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntUintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]uint8:
-		fastpathTV.DecMapIntUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUint8V(v, false, d)
 	case *map[int]uint8:
-		v2, changed2 := fastpathTV.DecMapIntUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntUint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]uint16:
-		fastpathTV.DecMapIntUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUint16V(v, false, d)
 	case *map[int]uint16:
-		v2, changed2 := fastpathTV.DecMapIntUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntUint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]uint32:
-		fastpathTV.DecMapIntUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUint32V(v, false, d)
 	case *map[int]uint32:
-		v2, changed2 := fastpathTV.DecMapIntUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntUint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]uint64:
-		fastpathTV.DecMapIntUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUint64V(v, false, d)
 	case *map[int]uint64:
-		v2, changed2 := fastpathTV.DecMapIntUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntUint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]uintptr:
-		fastpathTV.DecMapIntUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUintptrV(v, false, d)
 	case *map[int]uintptr:
-		v2, changed2 := fastpathTV.DecMapIntUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntUintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]int:
-		fastpathTV.DecMapIntIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntIntV(v, false, d)
 	case *map[int]int:
-		v2, changed2 := fastpathTV.DecMapIntIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntIntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]int8:
-		fastpathTV.DecMapIntInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntInt8V(v, false, d)
 	case *map[int]int8:
-		v2, changed2 := fastpathTV.DecMapIntInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntInt8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]int16:
-		fastpathTV.DecMapIntInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntInt16V(v, false, d)
 	case *map[int]int16:
-		v2, changed2 := fastpathTV.DecMapIntInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntInt16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]int32:
-		fastpathTV.DecMapIntInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntInt32V(v, false, d)
 	case *map[int]int32:
-		v2, changed2 := fastpathTV.DecMapIntInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntInt32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]int64:
-		fastpathTV.DecMapIntInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntInt64V(v, false, d)
 	case *map[int]int64:
-		v2, changed2 := fastpathTV.DecMapIntInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntInt64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]float32:
-		fastpathTV.DecMapIntFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntFloat32V(v, false, d)
 	case *map[int]float32:
-		v2, changed2 := fastpathTV.DecMapIntFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntFloat32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]float64:
-		fastpathTV.DecMapIntFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntFloat64V(v, false, d)
 	case *map[int]float64:
-		v2, changed2 := fastpathTV.DecMapIntFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntFloat64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int]bool:
-		fastpathTV.DecMapIntBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntBoolV(v, false, d)
 	case *map[int]bool:
-		v2, changed2 := fastpathTV.DecMapIntBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapIntBoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []int8:
-		fastpathTV.DecSliceInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceInt8V(v, false, d)
 	case *[]int8:
-		v2, changed2 := fastpathTV.DecSliceInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceInt8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]interface{}:
-		fastpathTV.DecMapInt8IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8IntfV(v, false, d)
 	case *map[int8]interface{}:
-		v2, changed2 := fastpathTV.DecMapInt8IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8IntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]string:
-		fastpathTV.DecMapInt8StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8StringV(v, false, d)
 	case *map[int8]string:
-		v2, changed2 := fastpathTV.DecMapInt8StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8StringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]uint:
-		fastpathTV.DecMapInt8UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8UintV(v, false, d)
 	case *map[int8]uint:
-		v2, changed2 := fastpathTV.DecMapInt8UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8UintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]uint8:
-		fastpathTV.DecMapInt8Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Uint8V(v, false, d)
 	case *map[int8]uint8:
-		v2, changed2 := fastpathTV.DecMapInt8Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8Uint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]uint16:
-		fastpathTV.DecMapInt8Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Uint16V(v, false, d)
 	case *map[int8]uint16:
-		v2, changed2 := fastpathTV.DecMapInt8Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8Uint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]uint32:
-		fastpathTV.DecMapInt8Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Uint32V(v, false, d)
 	case *map[int8]uint32:
-		v2, changed2 := fastpathTV.DecMapInt8Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8Uint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]uint64:
-		fastpathTV.DecMapInt8Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Uint64V(v, false, d)
 	case *map[int8]uint64:
-		v2, changed2 := fastpathTV.DecMapInt8Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8Uint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]uintptr:
-		fastpathTV.DecMapInt8UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8UintptrV(v, false, d)
 	case *map[int8]uintptr:
-		v2, changed2 := fastpathTV.DecMapInt8UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8UintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]int:
-		fastpathTV.DecMapInt8IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8IntV(v, false, d)
 	case *map[int8]int:
-		v2, changed2 := fastpathTV.DecMapInt8IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8IntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]int8:
-		fastpathTV.DecMapInt8Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Int8V(v, false, d)
 	case *map[int8]int8:
-		v2, changed2 := fastpathTV.DecMapInt8Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8Int8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]int16:
-		fastpathTV.DecMapInt8Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Int16V(v, false, d)
 	case *map[int8]int16:
-		v2, changed2 := fastpathTV.DecMapInt8Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8Int16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]int32:
-		fastpathTV.DecMapInt8Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Int32V(v, false, d)
 	case *map[int8]int32:
-		v2, changed2 := fastpathTV.DecMapInt8Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8Int32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]int64:
-		fastpathTV.DecMapInt8Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Int64V(v, false, d)
 	case *map[int8]int64:
-		v2, changed2 := fastpathTV.DecMapInt8Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8Int64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]float32:
-		fastpathTV.DecMapInt8Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Float32V(v, false, d)
 	case *map[int8]float32:
-		v2, changed2 := fastpathTV.DecMapInt8Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8Float32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]float64:
-		fastpathTV.DecMapInt8Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Float64V(v, false, d)
 	case *map[int8]float64:
-		v2, changed2 := fastpathTV.DecMapInt8Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8Float64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int8]bool:
-		fastpathTV.DecMapInt8BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8BoolV(v, false, d)
 	case *map[int8]bool:
-		v2, changed2 := fastpathTV.DecMapInt8BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt8BoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []int16:
-		fastpathTV.DecSliceInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceInt16V(v, false, d)
 	case *[]int16:
-		v2, changed2 := fastpathTV.DecSliceInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceInt16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]interface{}:
-		fastpathTV.DecMapInt16IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16IntfV(v, false, d)
 	case *map[int16]interface{}:
-		v2, changed2 := fastpathTV.DecMapInt16IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16IntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]string:
-		fastpathTV.DecMapInt16StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16StringV(v, false, d)
 	case *map[int16]string:
-		v2, changed2 := fastpathTV.DecMapInt16StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16StringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]uint:
-		fastpathTV.DecMapInt16UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16UintV(v, false, d)
 	case *map[int16]uint:
-		v2, changed2 := fastpathTV.DecMapInt16UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16UintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]uint8:
-		fastpathTV.DecMapInt16Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Uint8V(v, false, d)
 	case *map[int16]uint8:
-		v2, changed2 := fastpathTV.DecMapInt16Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16Uint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]uint16:
-		fastpathTV.DecMapInt16Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Uint16V(v, false, d)
 	case *map[int16]uint16:
-		v2, changed2 := fastpathTV.DecMapInt16Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16Uint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]uint32:
-		fastpathTV.DecMapInt16Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Uint32V(v, false, d)
 	case *map[int16]uint32:
-		v2, changed2 := fastpathTV.DecMapInt16Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16Uint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]uint64:
-		fastpathTV.DecMapInt16Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Uint64V(v, false, d)
 	case *map[int16]uint64:
-		v2, changed2 := fastpathTV.DecMapInt16Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16Uint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]uintptr:
-		fastpathTV.DecMapInt16UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16UintptrV(v, false, d)
 	case *map[int16]uintptr:
-		v2, changed2 := fastpathTV.DecMapInt16UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16UintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]int:
-		fastpathTV.DecMapInt16IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16IntV(v, false, d)
 	case *map[int16]int:
-		v2, changed2 := fastpathTV.DecMapInt16IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16IntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]int8:
-		fastpathTV.DecMapInt16Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Int8V(v, false, d)
 	case *map[int16]int8:
-		v2, changed2 := fastpathTV.DecMapInt16Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16Int8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]int16:
-		fastpathTV.DecMapInt16Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Int16V(v, false, d)
 	case *map[int16]int16:
-		v2, changed2 := fastpathTV.DecMapInt16Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16Int16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]int32:
-		fastpathTV.DecMapInt16Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Int32V(v, false, d)
 	case *map[int16]int32:
-		v2, changed2 := fastpathTV.DecMapInt16Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16Int32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]int64:
-		fastpathTV.DecMapInt16Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Int64V(v, false, d)
 	case *map[int16]int64:
-		v2, changed2 := fastpathTV.DecMapInt16Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16Int64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]float32:
-		fastpathTV.DecMapInt16Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Float32V(v, false, d)
 	case *map[int16]float32:
-		v2, changed2 := fastpathTV.DecMapInt16Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16Float32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]float64:
-		fastpathTV.DecMapInt16Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Float64V(v, false, d)
 	case *map[int16]float64:
-		v2, changed2 := fastpathTV.DecMapInt16Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16Float64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int16]bool:
-		fastpathTV.DecMapInt16BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16BoolV(v, false, d)
 	case *map[int16]bool:
-		v2, changed2 := fastpathTV.DecMapInt16BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt16BoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []int32:
-		fastpathTV.DecSliceInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceInt32V(v, false, d)
 	case *[]int32:
-		v2, changed2 := fastpathTV.DecSliceInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceInt32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]interface{}:
-		fastpathTV.DecMapInt32IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32IntfV(v, false, d)
 	case *map[int32]interface{}:
-		v2, changed2 := fastpathTV.DecMapInt32IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32IntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]string:
-		fastpathTV.DecMapInt32StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32StringV(v, false, d)
 	case *map[int32]string:
-		v2, changed2 := fastpathTV.DecMapInt32StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32StringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]uint:
-		fastpathTV.DecMapInt32UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32UintV(v, false, d)
 	case *map[int32]uint:
-		v2, changed2 := fastpathTV.DecMapInt32UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32UintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]uint8:
-		fastpathTV.DecMapInt32Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Uint8V(v, false, d)
 	case *map[int32]uint8:
-		v2, changed2 := fastpathTV.DecMapInt32Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32Uint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]uint16:
-		fastpathTV.DecMapInt32Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Uint16V(v, false, d)
 	case *map[int32]uint16:
-		v2, changed2 := fastpathTV.DecMapInt32Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32Uint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]uint32:
-		fastpathTV.DecMapInt32Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Uint32V(v, false, d)
 	case *map[int32]uint32:
-		v2, changed2 := fastpathTV.DecMapInt32Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32Uint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]uint64:
-		fastpathTV.DecMapInt32Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Uint64V(v, false, d)
 	case *map[int32]uint64:
-		v2, changed2 := fastpathTV.DecMapInt32Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32Uint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]uintptr:
-		fastpathTV.DecMapInt32UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32UintptrV(v, false, d)
 	case *map[int32]uintptr:
-		v2, changed2 := fastpathTV.DecMapInt32UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32UintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]int:
-		fastpathTV.DecMapInt32IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32IntV(v, false, d)
 	case *map[int32]int:
-		v2, changed2 := fastpathTV.DecMapInt32IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32IntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]int8:
-		fastpathTV.DecMapInt32Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Int8V(v, false, d)
 	case *map[int32]int8:
-		v2, changed2 := fastpathTV.DecMapInt32Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32Int8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]int16:
-		fastpathTV.DecMapInt32Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Int16V(v, false, d)
 	case *map[int32]int16:
-		v2, changed2 := fastpathTV.DecMapInt32Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32Int16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]int32:
-		fastpathTV.DecMapInt32Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Int32V(v, false, d)
 	case *map[int32]int32:
-		v2, changed2 := fastpathTV.DecMapInt32Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32Int32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]int64:
-		fastpathTV.DecMapInt32Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Int64V(v, false, d)
 	case *map[int32]int64:
-		v2, changed2 := fastpathTV.DecMapInt32Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32Int64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]float32:
-		fastpathTV.DecMapInt32Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Float32V(v, false, d)
 	case *map[int32]float32:
-		v2, changed2 := fastpathTV.DecMapInt32Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32Float32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]float64:
-		fastpathTV.DecMapInt32Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Float64V(v, false, d)
 	case *map[int32]float64:
-		v2, changed2 := fastpathTV.DecMapInt32Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32Float64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int32]bool:
-		fastpathTV.DecMapInt32BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32BoolV(v, false, d)
 	case *map[int32]bool:
-		v2, changed2 := fastpathTV.DecMapInt32BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt32BoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []int64:
-		fastpathTV.DecSliceInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceInt64V(v, false, d)
 	case *[]int64:
-		v2, changed2 := fastpathTV.DecSliceInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceInt64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]interface{}:
-		fastpathTV.DecMapInt64IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64IntfV(v, false, d)
 	case *map[int64]interface{}:
-		v2, changed2 := fastpathTV.DecMapInt64IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64IntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]string:
-		fastpathTV.DecMapInt64StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64StringV(v, false, d)
 	case *map[int64]string:
-		v2, changed2 := fastpathTV.DecMapInt64StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64StringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]uint:
-		fastpathTV.DecMapInt64UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64UintV(v, false, d)
 	case *map[int64]uint:
-		v2, changed2 := fastpathTV.DecMapInt64UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64UintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]uint8:
-		fastpathTV.DecMapInt64Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Uint8V(v, false, d)
 	case *map[int64]uint8:
-		v2, changed2 := fastpathTV.DecMapInt64Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64Uint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]uint16:
-		fastpathTV.DecMapInt64Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Uint16V(v, false, d)
 	case *map[int64]uint16:
-		v2, changed2 := fastpathTV.DecMapInt64Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64Uint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]uint32:
-		fastpathTV.DecMapInt64Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Uint32V(v, false, d)
 	case *map[int64]uint32:
-		v2, changed2 := fastpathTV.DecMapInt64Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64Uint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]uint64:
-		fastpathTV.DecMapInt64Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Uint64V(v, false, d)
 	case *map[int64]uint64:
-		v2, changed2 := fastpathTV.DecMapInt64Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64Uint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]uintptr:
-		fastpathTV.DecMapInt64UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64UintptrV(v, false, d)
 	case *map[int64]uintptr:
-		v2, changed2 := fastpathTV.DecMapInt64UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64UintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]int:
-		fastpathTV.DecMapInt64IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64IntV(v, false, d)
 	case *map[int64]int:
-		v2, changed2 := fastpathTV.DecMapInt64IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64IntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]int8:
-		fastpathTV.DecMapInt64Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Int8V(v, false, d)
 	case *map[int64]int8:
-		v2, changed2 := fastpathTV.DecMapInt64Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64Int8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]int16:
-		fastpathTV.DecMapInt64Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Int16V(v, false, d)
 	case *map[int64]int16:
-		v2, changed2 := fastpathTV.DecMapInt64Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64Int16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]int32:
-		fastpathTV.DecMapInt64Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Int32V(v, false, d)
 	case *map[int64]int32:
-		v2, changed2 := fastpathTV.DecMapInt64Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64Int32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]int64:
-		fastpathTV.DecMapInt64Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Int64V(v, false, d)
 	case *map[int64]int64:
-		v2, changed2 := fastpathTV.DecMapInt64Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64Int64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]float32:
-		fastpathTV.DecMapInt64Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Float32V(v, false, d)
 	case *map[int64]float32:
-		v2, changed2 := fastpathTV.DecMapInt64Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64Float32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]float64:
-		fastpathTV.DecMapInt64Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Float64V(v, false, d)
 	case *map[int64]float64:
-		v2, changed2 := fastpathTV.DecMapInt64Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64Float64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[int64]bool:
-		fastpathTV.DecMapInt64BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64BoolV(v, false, d)
 	case *map[int64]bool:
-		v2, changed2 := fastpathTV.DecMapInt64BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapInt64BoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case []bool:
-		fastpathTV.DecSliceBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecSliceBoolV(v, false, d)
 	case *[]bool:
-		v2, changed2 := fastpathTV.DecSliceBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecSliceBoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]interface{}:
-		fastpathTV.DecMapBoolIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolIntfV(v, false, d)
 	case *map[bool]interface{}:
-		v2, changed2 := fastpathTV.DecMapBoolIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolIntfV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]string:
-		fastpathTV.DecMapBoolStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolStringV(v, false, d)
 	case *map[bool]string:
-		v2, changed2 := fastpathTV.DecMapBoolStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolStringV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]uint:
-		fastpathTV.DecMapBoolUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUintV(v, false, d)
 	case *map[bool]uint:
-		v2, changed2 := fastpathTV.DecMapBoolUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolUintV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]uint8:
-		fastpathTV.DecMapBoolUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUint8V(v, false, d)
 	case *map[bool]uint8:
-		v2, changed2 := fastpathTV.DecMapBoolUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolUint8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]uint16:
-		fastpathTV.DecMapBoolUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUint16V(v, false, d)
 	case *map[bool]uint16:
-		v2, changed2 := fastpathTV.DecMapBoolUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolUint16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]uint32:
-		fastpathTV.DecMapBoolUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUint32V(v, false, d)
 	case *map[bool]uint32:
-		v2, changed2 := fastpathTV.DecMapBoolUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolUint32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]uint64:
-		fastpathTV.DecMapBoolUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUint64V(v, false, d)
 	case *map[bool]uint64:
-		v2, changed2 := fastpathTV.DecMapBoolUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolUint64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]uintptr:
-		fastpathTV.DecMapBoolUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUintptrV(v, false, d)
 	case *map[bool]uintptr:
-		v2, changed2 := fastpathTV.DecMapBoolUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolUintptrV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]int:
-		fastpathTV.DecMapBoolIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolIntV(v, false, d)
 	case *map[bool]int:
-		v2, changed2 := fastpathTV.DecMapBoolIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolIntV(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]int8:
-		fastpathTV.DecMapBoolInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolInt8V(v, false, d)
 	case *map[bool]int8:
-		v2, changed2 := fastpathTV.DecMapBoolInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolInt8V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]int16:
-		fastpathTV.DecMapBoolInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolInt16V(v, false, d)
 	case *map[bool]int16:
-		v2, changed2 := fastpathTV.DecMapBoolInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolInt16V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]int32:
-		fastpathTV.DecMapBoolInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolInt32V(v, false, d)
 	case *map[bool]int32:
-		v2, changed2 := fastpathTV.DecMapBoolInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolInt32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]int64:
-		fastpathTV.DecMapBoolInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolInt64V(v, false, d)
 	case *map[bool]int64:
-		v2, changed2 := fastpathTV.DecMapBoolInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolInt64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]float32:
-		fastpathTV.DecMapBoolFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolFloat32V(v, false, d)
 	case *map[bool]float32:
-		v2, changed2 := fastpathTV.DecMapBoolFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolFloat32V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]float64:
-		fastpathTV.DecMapBoolFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolFloat64V(v, false, d)
 	case *map[bool]float64:
-		v2, changed2 := fastpathTV.DecMapBoolFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolFloat64V(*v, true, d); changed2 {
 			*v = v2
 		}
 
 	case map[bool]bool:
-		fastpathTV.DecMapBoolBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolBoolV(v, false, d)
 	case *map[bool]bool:
-		v2, changed2 := fastpathTV.DecMapBoolBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		if v2, changed2 := fastpathTV.DecMapBoolBoolV(*v, true, d); changed2 {
 			*v = v2
 		}
 
@@ -18121,38 +15851,850 @@ func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
 	return true
 }
 
+func fastpathDecodeSetZeroTypeSwitch(iv interface{}, d *Decoder) bool {
+	switch v := iv.(type) {
+
+	case *[]interface{}:
+		*v = nil
+
+	case *map[interface{}]interface{}:
+		*v = nil
+
+	case *map[interface{}]string:
+		*v = nil
+
+	case *map[interface{}]uint:
+		*v = nil
+
+	case *map[interface{}]uint8:
+		*v = nil
+
+	case *map[interface{}]uint16:
+		*v = nil
+
+	case *map[interface{}]uint32:
+		*v = nil
+
+	case *map[interface{}]uint64:
+		*v = nil
+
+	case *map[interface{}]uintptr:
+		*v = nil
+
+	case *map[interface{}]int:
+		*v = nil
+
+	case *map[interface{}]int8:
+		*v = nil
+
+	case *map[interface{}]int16:
+		*v = nil
+
+	case *map[interface{}]int32:
+		*v = nil
+
+	case *map[interface{}]int64:
+		*v = nil
+
+	case *map[interface{}]float32:
+		*v = nil
+
+	case *map[interface{}]float64:
+		*v = nil
+
+	case *map[interface{}]bool:
+		*v = nil
+
+	case *[]string:
+		*v = nil
+
+	case *map[string]interface{}:
+		*v = nil
+
+	case *map[string]string:
+		*v = nil
+
+	case *map[string]uint:
+		*v = nil
+
+	case *map[string]uint8:
+		*v = nil
+
+	case *map[string]uint16:
+		*v = nil
+
+	case *map[string]uint32:
+		*v = nil
+
+	case *map[string]uint64:
+		*v = nil
+
+	case *map[string]uintptr:
+		*v = nil
+
+	case *map[string]int:
+		*v = nil
+
+	case *map[string]int8:
+		*v = nil
+
+	case *map[string]int16:
+		*v = nil
+
+	case *map[string]int32:
+		*v = nil
+
+	case *map[string]int64:
+		*v = nil
+
+	case *map[string]float32:
+		*v = nil
+
+	case *map[string]float64:
+		*v = nil
+
+	case *map[string]bool:
+		*v = nil
+
+	case *[]float32:
+		*v = nil
+
+	case *map[float32]interface{}:
+		*v = nil
+
+	case *map[float32]string:
+		*v = nil
+
+	case *map[float32]uint:
+		*v = nil
+
+	case *map[float32]uint8:
+		*v = nil
+
+	case *map[float32]uint16:
+		*v = nil
+
+	case *map[float32]uint32:
+		*v = nil
+
+	case *map[float32]uint64:
+		*v = nil
+
+	case *map[float32]uintptr:
+		*v = nil
+
+	case *map[float32]int:
+		*v = nil
+
+	case *map[float32]int8:
+		*v = nil
+
+	case *map[float32]int16:
+		*v = nil
+
+	case *map[float32]int32:
+		*v = nil
+
+	case *map[float32]int64:
+		*v = nil
+
+	case *map[float32]float32:
+		*v = nil
+
+	case *map[float32]float64:
+		*v = nil
+
+	case *map[float32]bool:
+		*v = nil
+
+	case *[]float64:
+		*v = nil
+
+	case *map[float64]interface{}:
+		*v = nil
+
+	case *map[float64]string:
+		*v = nil
+
+	case *map[float64]uint:
+		*v = nil
+
+	case *map[float64]uint8:
+		*v = nil
+
+	case *map[float64]uint16:
+		*v = nil
+
+	case *map[float64]uint32:
+		*v = nil
+
+	case *map[float64]uint64:
+		*v = nil
+
+	case *map[float64]uintptr:
+		*v = nil
+
+	case *map[float64]int:
+		*v = nil
+
+	case *map[float64]int8:
+		*v = nil
+
+	case *map[float64]int16:
+		*v = nil
+
+	case *map[float64]int32:
+		*v = nil
+
+	case *map[float64]int64:
+		*v = nil
+
+	case *map[float64]float32:
+		*v = nil
+
+	case *map[float64]float64:
+		*v = nil
+
+	case *map[float64]bool:
+		*v = nil
+
+	case *[]uint:
+		*v = nil
+
+	case *map[uint]interface{}:
+		*v = nil
+
+	case *map[uint]string:
+		*v = nil
+
+	case *map[uint]uint:
+		*v = nil
+
+	case *map[uint]uint8:
+		*v = nil
+
+	case *map[uint]uint16:
+		*v = nil
+
+	case *map[uint]uint32:
+		*v = nil
+
+	case *map[uint]uint64:
+		*v = nil
+
+	case *map[uint]uintptr:
+		*v = nil
+
+	case *map[uint]int:
+		*v = nil
+
+	case *map[uint]int8:
+		*v = nil
+
+	case *map[uint]int16:
+		*v = nil
+
+	case *map[uint]int32:
+		*v = nil
+
+	case *map[uint]int64:
+		*v = nil
+
+	case *map[uint]float32:
+		*v = nil
+
+	case *map[uint]float64:
+		*v = nil
+
+	case *map[uint]bool:
+		*v = nil
+
+	case *map[uint8]interface{}:
+		*v = nil
+
+	case *map[uint8]string:
+		*v = nil
+
+	case *map[uint8]uint:
+		*v = nil
+
+	case *map[uint8]uint8:
+		*v = nil
+
+	case *map[uint8]uint16:
+		*v = nil
+
+	case *map[uint8]uint32:
+		*v = nil
+
+	case *map[uint8]uint64:
+		*v = nil
+
+	case *map[uint8]uintptr:
+		*v = nil
+
+	case *map[uint8]int:
+		*v = nil
+
+	case *map[uint8]int8:
+		*v = nil
+
+	case *map[uint8]int16:
+		*v = nil
+
+	case *map[uint8]int32:
+		*v = nil
+
+	case *map[uint8]int64:
+		*v = nil
+
+	case *map[uint8]float32:
+		*v = nil
+
+	case *map[uint8]float64:
+		*v = nil
+
+	case *map[uint8]bool:
+		*v = nil
+
+	case *[]uint16:
+		*v = nil
+
+	case *map[uint16]interface{}:
+		*v = nil
+
+	case *map[uint16]string:
+		*v = nil
+
+	case *map[uint16]uint:
+		*v = nil
+
+	case *map[uint16]uint8:
+		*v = nil
+
+	case *map[uint16]uint16:
+		*v = nil
+
+	case *map[uint16]uint32:
+		*v = nil
+
+	case *map[uint16]uint64:
+		*v = nil
+
+	case *map[uint16]uintptr:
+		*v = nil
+
+	case *map[uint16]int:
+		*v = nil
+
+	case *map[uint16]int8:
+		*v = nil
+
+	case *map[uint16]int16:
+		*v = nil
+
+	case *map[uint16]int32:
+		*v = nil
+
+	case *map[uint16]int64:
+		*v = nil
+
+	case *map[uint16]float32:
+		*v = nil
+
+	case *map[uint16]float64:
+		*v = nil
+
+	case *map[uint16]bool:
+		*v = nil
+
+	case *[]uint32:
+		*v = nil
+
+	case *map[uint32]interface{}:
+		*v = nil
+
+	case *map[uint32]string:
+		*v = nil
+
+	case *map[uint32]uint:
+		*v = nil
+
+	case *map[uint32]uint8:
+		*v = nil
+
+	case *map[uint32]uint16:
+		*v = nil
+
+	case *map[uint32]uint32:
+		*v = nil
+
+	case *map[uint32]uint64:
+		*v = nil
+
+	case *map[uint32]uintptr:
+		*v = nil
+
+	case *map[uint32]int:
+		*v = nil
+
+	case *map[uint32]int8:
+		*v = nil
+
+	case *map[uint32]int16:
+		*v = nil
+
+	case *map[uint32]int32:
+		*v = nil
+
+	case *map[uint32]int64:
+		*v = nil
+
+	case *map[uint32]float32:
+		*v = nil
+
+	case *map[uint32]float64:
+		*v = nil
+
+	case *map[uint32]bool:
+		*v = nil
+
+	case *[]uint64:
+		*v = nil
+
+	case *map[uint64]interface{}:
+		*v = nil
+
+	case *map[uint64]string:
+		*v = nil
+
+	case *map[uint64]uint:
+		*v = nil
+
+	case *map[uint64]uint8:
+		*v = nil
+
+	case *map[uint64]uint16:
+		*v = nil
+
+	case *map[uint64]uint32:
+		*v = nil
+
+	case *map[uint64]uint64:
+		*v = nil
+
+	case *map[uint64]uintptr:
+		*v = nil
+
+	case *map[uint64]int:
+		*v = nil
+
+	case *map[uint64]int8:
+		*v = nil
+
+	case *map[uint64]int16:
+		*v = nil
+
+	case *map[uint64]int32:
+		*v = nil
+
+	case *map[uint64]int64:
+		*v = nil
+
+	case *map[uint64]float32:
+		*v = nil
+
+	case *map[uint64]float64:
+		*v = nil
+
+	case *map[uint64]bool:
+		*v = nil
+
+	case *[]uintptr:
+		*v = nil
+
+	case *map[uintptr]interface{}:
+		*v = nil
+
+	case *map[uintptr]string:
+		*v = nil
+
+	case *map[uintptr]uint:
+		*v = nil
+
+	case *map[uintptr]uint8:
+		*v = nil
+
+	case *map[uintptr]uint16:
+		*v = nil
+
+	case *map[uintptr]uint32:
+		*v = nil
+
+	case *map[uintptr]uint64:
+		*v = nil
+
+	case *map[uintptr]uintptr:
+		*v = nil
+
+	case *map[uintptr]int:
+		*v = nil
+
+	case *map[uintptr]int8:
+		*v = nil
+
+	case *map[uintptr]int16:
+		*v = nil
+
+	case *map[uintptr]int32:
+		*v = nil
+
+	case *map[uintptr]int64:
+		*v = nil
+
+	case *map[uintptr]float32:
+		*v = nil
+
+	case *map[uintptr]float64:
+		*v = nil
+
+	case *map[uintptr]bool:
+		*v = nil
+
+	case *[]int:
+		*v = nil
+
+	case *map[int]interface{}:
+		*v = nil
+
+	case *map[int]string:
+		*v = nil
+
+	case *map[int]uint:
+		*v = nil
+
+	case *map[int]uint8:
+		*v = nil
+
+	case *map[int]uint16:
+		*v = nil
+
+	case *map[int]uint32:
+		*v = nil
+
+	case *map[int]uint64:
+		*v = nil
+
+	case *map[int]uintptr:
+		*v = nil
+
+	case *map[int]int:
+		*v = nil
+
+	case *map[int]int8:
+		*v = nil
+
+	case *map[int]int16:
+		*v = nil
+
+	case *map[int]int32:
+		*v = nil
+
+	case *map[int]int64:
+		*v = nil
+
+	case *map[int]float32:
+		*v = nil
+
+	case *map[int]float64:
+		*v = nil
+
+	case *map[int]bool:
+		*v = nil
+
+	case *[]int8:
+		*v = nil
+
+	case *map[int8]interface{}:
+		*v = nil
+
+	case *map[int8]string:
+		*v = nil
+
+	case *map[int8]uint:
+		*v = nil
+
+	case *map[int8]uint8:
+		*v = nil
+
+	case *map[int8]uint16:
+		*v = nil
+
+	case *map[int8]uint32:
+		*v = nil
+
+	case *map[int8]uint64:
+		*v = nil
+
+	case *map[int8]uintptr:
+		*v = nil
+
+	case *map[int8]int:
+		*v = nil
+
+	case *map[int8]int8:
+		*v = nil
+
+	case *map[int8]int16:
+		*v = nil
+
+	case *map[int8]int32:
+		*v = nil
+
+	case *map[int8]int64:
+		*v = nil
+
+	case *map[int8]float32:
+		*v = nil
+
+	case *map[int8]float64:
+		*v = nil
+
+	case *map[int8]bool:
+		*v = nil
+
+	case *[]int16:
+		*v = nil
+
+	case *map[int16]interface{}:
+		*v = nil
+
+	case *map[int16]string:
+		*v = nil
+
+	case *map[int16]uint:
+		*v = nil
+
+	case *map[int16]uint8:
+		*v = nil
+
+	case *map[int16]uint16:
+		*v = nil
+
+	case *map[int16]uint32:
+		*v = nil
+
+	case *map[int16]uint64:
+		*v = nil
+
+	case *map[int16]uintptr:
+		*v = nil
+
+	case *map[int16]int:
+		*v = nil
+
+	case *map[int16]int8:
+		*v = nil
+
+	case *map[int16]int16:
+		*v = nil
+
+	case *map[int16]int32:
+		*v = nil
+
+	case *map[int16]int64:
+		*v = nil
+
+	case *map[int16]float32:
+		*v = nil
+
+	case *map[int16]float64:
+		*v = nil
+
+	case *map[int16]bool:
+		*v = nil
+
+	case *[]int32:
+		*v = nil
+
+	case *map[int32]interface{}:
+		*v = nil
+
+	case *map[int32]string:
+		*v = nil
+
+	case *map[int32]uint:
+		*v = nil
+
+	case *map[int32]uint8:
+		*v = nil
+
+	case *map[int32]uint16:
+		*v = nil
+
+	case *map[int32]uint32:
+		*v = nil
+
+	case *map[int32]uint64:
+		*v = nil
+
+	case *map[int32]uintptr:
+		*v = nil
+
+	case *map[int32]int:
+		*v = nil
+
+	case *map[int32]int8:
+		*v = nil
+
+	case *map[int32]int16:
+		*v = nil
+
+	case *map[int32]int32:
+		*v = nil
+
+	case *map[int32]int64:
+		*v = nil
+
+	case *map[int32]float32:
+		*v = nil
+
+	case *map[int32]float64:
+		*v = nil
+
+	case *map[int32]bool:
+		*v = nil
+
+	case *[]int64:
+		*v = nil
+
+	case *map[int64]interface{}:
+		*v = nil
+
+	case *map[int64]string:
+		*v = nil
+
+	case *map[int64]uint:
+		*v = nil
+
+	case *map[int64]uint8:
+		*v = nil
+
+	case *map[int64]uint16:
+		*v = nil
+
+	case *map[int64]uint32:
+		*v = nil
+
+	case *map[int64]uint64:
+		*v = nil
+
+	case *map[int64]uintptr:
+		*v = nil
+
+	case *map[int64]int:
+		*v = nil
+
+	case *map[int64]int8:
+		*v = nil
+
+	case *map[int64]int16:
+		*v = nil
+
+	case *map[int64]int32:
+		*v = nil
+
+	case *map[int64]int64:
+		*v = nil
+
+	case *map[int64]float32:
+		*v = nil
+
+	case *map[int64]float64:
+		*v = nil
+
+	case *map[int64]bool:
+		*v = nil
+
+	case *[]bool:
+		*v = nil
+
+	case *map[bool]interface{}:
+		*v = nil
+
+	case *map[bool]string:
+		*v = nil
+
+	case *map[bool]uint:
+		*v = nil
+
+	case *map[bool]uint8:
+		*v = nil
+
+	case *map[bool]uint16:
+		*v = nil
+
+	case *map[bool]uint32:
+		*v = nil
+
+	case *map[bool]uint64:
+		*v = nil
+
+	case *map[bool]uintptr:
+		*v = nil
+
+	case *map[bool]int:
+		*v = nil
+
+	case *map[bool]int8:
+		*v = nil
+
+	case *map[bool]int16:
+		*v = nil
+
+	case *map[bool]int32:
+		*v = nil
+
+	case *map[bool]int64:
+		*v = nil
+
+	case *map[bool]float32:
+		*v = nil
+
+	case *map[bool]float64:
+		*v = nil
+
+	case *map[bool]bool:
+		*v = nil
+
+	default:
+		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
+		return false
+	}
+	return true
+}
+
 // -- -- fast path functions
 
-func (f *decFnInfo) fastpathDecSliceIntfR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]interface{})
-		v, changed := fastpathTV.DecSliceIntfV(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceIntfR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]interface{})
+		if v, changed := fastpathTV.DecSliceIntfV(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]interface{})
-		fastpathTV.DecSliceIntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceIntfV(rv2i(rv).([]interface{}), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceIntfX(vp *[]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceIntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceIntfX(vp *[]interface{}, d *Decoder) {
+	if v, changed := f.DecSliceIntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool, d *Decoder) (_ []interface{}, changed bool) {
+func (_ fastpathT) DecSliceIntfV(v []interface{}, canChange bool, d *Decoder) (_ []interface{}, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18167,126 +16709,83 @@ func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool,
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 16)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]interface{}, xlen)
-					}
-				} else {
-					v = make([]interface{}, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]interface{}, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			d.decode(&v[j])
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, nil)
-				slh.ElemContainerState(j)
-				d.decode(&v[j])
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []interface{}{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]interface{}, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, nil)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				d.decode(&v[j])
-
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]interface{}, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, nil)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			d.decode(&v[j])
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]interface{}, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceStringR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]string)
-		v, changed := fastpathTV.DecSliceStringV(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceStringR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]string)
+		if v, changed := fastpathTV.DecSliceStringV(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]string)
-		fastpathTV.DecSliceStringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceStringV(rv2i(rv).([]string), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceStringX(vp *[]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceStringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceStringX(vp *[]string, d *Decoder) {
+	if v, changed := f.DecSliceStringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d *Decoder) (_ []string, changed bool) {
+func (_ fastpathT) DecSliceStringV(v []string, canChange bool, d *Decoder) (_ []string, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18301,125 +16800,83 @@ func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 16)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]string, xlen)
-					}
-				} else {
-					v = make([]string, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]string, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = dd.DecodeString()
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, "")
-				slh.ElemContainerState(j)
-				v[j] = dd.DecodeString()
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []string{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]string, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, "")
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = dd.DecodeString()
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]string, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, "")
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = dd.DecodeString()
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]string, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceFloat32R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]float32)
-		v, changed := fastpathTV.DecSliceFloat32V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]float32)
+		if v, changed := fastpathTV.DecSliceFloat32V(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]float32)
-		fastpathTV.DecSliceFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceFloat32V(rv2i(rv).([]float32), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceFloat32X(vp *[]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceFloat32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceFloat32X(vp *[]float32, d *Decoder) {
+	if v, changed := f.DecSliceFloat32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool, d *Decoder) (_ []float32, changed bool) {
+func (_ fastpathT) DecSliceFloat32V(v []float32, canChange bool, d *Decoder) (_ []float32, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18434,125 +16891,83 @@ func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool,
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]float32, xlen)
-					}
-				} else {
-					v = make([]float32, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]float32, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = float32(dd.DecodeFloat(true))
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = float32(dd.DecodeFloat(true))
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []float32{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]float32, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = float32(dd.DecodeFloat(true))
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]float32, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = float32(dd.DecodeFloat(true))
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]float32, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceFloat64R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]float64)
-		v, changed := fastpathTV.DecSliceFloat64V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]float64)
+		if v, changed := fastpathTV.DecSliceFloat64V(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]float64)
-		fastpathTV.DecSliceFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceFloat64V(rv2i(rv).([]float64), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceFloat64X(vp *[]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceFloat64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceFloat64X(vp *[]float64, d *Decoder) {
+	if v, changed := f.DecSliceFloat64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool, d *Decoder) (_ []float64, changed bool) {
+func (_ fastpathT) DecSliceFloat64V(v []float64, canChange bool, d *Decoder) (_ []float64, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18567,125 +16982,83 @@ func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool,
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]float64, xlen)
-					}
-				} else {
-					v = make([]float64, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]float64, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = dd.DecodeFloat(false)
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = dd.DecodeFloat(false)
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []float64{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]float64, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = dd.DecodeFloat(false)
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]float64, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = dd.DecodeFloat(false)
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]float64, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceUintR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]uint)
-		v, changed := fastpathTV.DecSliceUintV(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceUintR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]uint)
+		if v, changed := fastpathTV.DecSliceUintV(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]uint)
-		fastpathTV.DecSliceUintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceUintV(rv2i(rv).([]uint), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceUintX(vp *[]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceUintX(vp *[]uint, d *Decoder) {
+	if v, changed := f.DecSliceUintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d *Decoder) (_ []uint, changed bool) {
+func (_ fastpathT) DecSliceUintV(v []uint, canChange bool, d *Decoder) (_ []uint, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18700,125 +17073,83 @@ func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d *Dec
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]uint, xlen)
-					}
-				} else {
-					v = make([]uint, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]uint, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = uint(dd.DecodeUint(uintBitsize))
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = uint(dd.DecodeUint(uintBitsize))
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []uint{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]uint, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = uint(dd.DecodeUint(uintBitsize))
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]uint, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = uint(dd.DecodeUint(uintBitsize))
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]uint, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceUint16R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]uint16)
-		v, changed := fastpathTV.DecSliceUint16V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceUint16R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]uint16)
+		if v, changed := fastpathTV.DecSliceUint16V(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]uint16)
-		fastpathTV.DecSliceUint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceUint16V(rv2i(rv).([]uint16), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceUint16X(vp *[]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceUint16X(vp *[]uint16, d *Decoder) {
+	if v, changed := f.DecSliceUint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d *Decoder) (_ []uint16, changed bool) {
+func (_ fastpathT) DecSliceUint16V(v []uint16, canChange bool, d *Decoder) (_ []uint16, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18833,125 +17164,83 @@ func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 2)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]uint16, xlen)
-					}
-				} else {
-					v = make([]uint16, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]uint16, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = uint16(dd.DecodeUint(16))
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = uint16(dd.DecodeUint(16))
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []uint16{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]uint16, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = uint16(dd.DecodeUint(16))
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]uint16, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = uint16(dd.DecodeUint(16))
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]uint16, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceUint32R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]uint32)
-		v, changed := fastpathTV.DecSliceUint32V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceUint32R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]uint32)
+		if v, changed := fastpathTV.DecSliceUint32V(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]uint32)
-		fastpathTV.DecSliceUint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceUint32V(rv2i(rv).([]uint32), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceUint32X(vp *[]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceUint32X(vp *[]uint32, d *Decoder) {
+	if v, changed := f.DecSliceUint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d *Decoder) (_ []uint32, changed bool) {
+func (_ fastpathT) DecSliceUint32V(v []uint32, canChange bool, d *Decoder) (_ []uint32, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18966,125 +17255,83 @@ func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]uint32, xlen)
-					}
-				} else {
-					v = make([]uint32, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]uint32, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = uint32(dd.DecodeUint(32))
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = uint32(dd.DecodeUint(32))
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []uint32{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]uint32, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = uint32(dd.DecodeUint(32))
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]uint32, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = uint32(dd.DecodeUint(32))
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]uint32, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceUint64R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]uint64)
-		v, changed := fastpathTV.DecSliceUint64V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceUint64R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]uint64)
+		if v, changed := fastpathTV.DecSliceUint64V(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]uint64)
-		fastpathTV.DecSliceUint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceUint64V(rv2i(rv).([]uint64), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceUint64X(vp *[]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceUint64X(vp *[]uint64, d *Decoder) {
+	if v, changed := f.DecSliceUint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d *Decoder) (_ []uint64, changed bool) {
+func (_ fastpathT) DecSliceUint64V(v []uint64, canChange bool, d *Decoder) (_ []uint64, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19099,125 +17346,83 @@ func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]uint64, xlen)
-					}
-				} else {
-					v = make([]uint64, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]uint64, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = dd.DecodeUint(64)
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = dd.DecodeUint(64)
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []uint64{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]uint64, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = dd.DecodeUint(64)
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]uint64, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = dd.DecodeUint(64)
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]uint64, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceUintptrR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]uintptr)
-		v, changed := fastpathTV.DecSliceUintptrV(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]uintptr)
+		if v, changed := fastpathTV.DecSliceUintptrV(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]uintptr)
-		fastpathTV.DecSliceUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceUintptrV(rv2i(rv).([]uintptr), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, d *Decoder) {
+	if v, changed := f.DecSliceUintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool, d *Decoder) (_ []uintptr, changed bool) {
+func (_ fastpathT) DecSliceUintptrV(v []uintptr, canChange bool, d *Decoder) (_ []uintptr, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19232,125 +17437,83 @@ func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool,
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]uintptr, xlen)
-					}
-				} else {
-					v = make([]uintptr, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]uintptr, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = uintptr(dd.DecodeUint(uintBitsize))
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = uintptr(dd.DecodeUint(uintBitsize))
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []uintptr{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]uintptr, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = uintptr(dd.DecodeUint(uintBitsize))
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]uintptr, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = uintptr(dd.DecodeUint(uintBitsize))
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]uintptr, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceIntR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]int)
-		v, changed := fastpathTV.DecSliceIntV(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceIntR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]int)
+		if v, changed := fastpathTV.DecSliceIntV(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]int)
-		fastpathTV.DecSliceIntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceIntV(rv2i(rv).([]int), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceIntX(vp *[]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceIntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceIntX(vp *[]int, d *Decoder) {
+	if v, changed := f.DecSliceIntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d *Decoder) (_ []int, changed bool) {
+func (_ fastpathT) DecSliceIntV(v []int, canChange bool, d *Decoder) (_ []int, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19365,125 +17528,83 @@ func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d *Decod
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]int, xlen)
-					}
-				} else {
-					v = make([]int, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]int, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = int(dd.DecodeInt(intBitsize))
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = int(dd.DecodeInt(intBitsize))
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []int{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]int, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = int(dd.DecodeInt(intBitsize))
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]int, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = int(dd.DecodeInt(intBitsize))
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]int, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceInt8R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]int8)
-		v, changed := fastpathTV.DecSliceInt8V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceInt8R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]int8)
+		if v, changed := fastpathTV.DecSliceInt8V(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]int8)
-		fastpathTV.DecSliceInt8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceInt8V(rv2i(rv).([]int8), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceInt8X(vp *[]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceInt8X(vp *[]int8, d *Decoder) {
+	if v, changed := f.DecSliceInt8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d *Decoder) (_ []int8, changed bool) {
+func (_ fastpathT) DecSliceInt8V(v []int8, canChange bool, d *Decoder) (_ []int8, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19498,125 +17619,83 @@ func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d *Dec
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 1)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]int8, xlen)
-					}
-				} else {
-					v = make([]int8, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]int8, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = int8(dd.DecodeInt(8))
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = int8(dd.DecodeInt(8))
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []int8{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]int8, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = int8(dd.DecodeInt(8))
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]int8, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = int8(dd.DecodeInt(8))
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]int8, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceInt16R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]int16)
-		v, changed := fastpathTV.DecSliceInt16V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceInt16R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]int16)
+		if v, changed := fastpathTV.DecSliceInt16V(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]int16)
-		fastpathTV.DecSliceInt16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceInt16V(rv2i(rv).([]int16), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceInt16X(vp *[]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceInt16X(vp *[]int16, d *Decoder) {
+	if v, changed := f.DecSliceInt16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d *Decoder) (_ []int16, changed bool) {
+func (_ fastpathT) DecSliceInt16V(v []int16, canChange bool, d *Decoder) (_ []int16, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19631,125 +17710,83 @@ func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d *D
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 2)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]int16, xlen)
-					}
-				} else {
-					v = make([]int16, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]int16, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = int16(dd.DecodeInt(16))
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = int16(dd.DecodeInt(16))
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []int16{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]int16, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = int16(dd.DecodeInt(16))
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]int16, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = int16(dd.DecodeInt(16))
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]int16, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceInt32R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]int32)
-		v, changed := fastpathTV.DecSliceInt32V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceInt32R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]int32)
+		if v, changed := fastpathTV.DecSliceInt32V(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]int32)
-		fastpathTV.DecSliceInt32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceInt32V(rv2i(rv).([]int32), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceInt32X(vp *[]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceInt32X(vp *[]int32, d *Decoder) {
+	if v, changed := f.DecSliceInt32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d *Decoder) (_ []int32, changed bool) {
+func (_ fastpathT) DecSliceInt32V(v []int32, canChange bool, d *Decoder) (_ []int32, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19764,125 +17801,83 @@ func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d *D
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]int32, xlen)
-					}
-				} else {
-					v = make([]int32, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]int32, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = int32(dd.DecodeInt(32))
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = int32(dd.DecodeInt(32))
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []int32{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]int32, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = int32(dd.DecodeInt(32))
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]int32, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = int32(dd.DecodeInt(32))
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]int32, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceInt64R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]int64)
-		v, changed := fastpathTV.DecSliceInt64V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceInt64R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]int64)
+		if v, changed := fastpathTV.DecSliceInt64V(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]int64)
-		fastpathTV.DecSliceInt64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceInt64V(rv2i(rv).([]int64), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceInt64X(vp *[]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceInt64X(vp *[]int64, d *Decoder) {
+	if v, changed := f.DecSliceInt64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d *Decoder) (_ []int64, changed bool) {
+func (_ fastpathT) DecSliceInt64V(v []int64, canChange bool, d *Decoder) (_ []int64, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19897,125 +17892,83 @@ func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d *D
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]int64, xlen)
-					}
-				} else {
-					v = make([]int64, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]int64, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = dd.DecodeInt(64)
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, 0)
-				slh.ElemContainerState(j)
-				v[j] = dd.DecodeInt(64)
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []int64{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]int64, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, 0)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = dd.DecodeInt(64)
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]int64, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = dd.DecodeInt(64)
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]int64, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceBoolR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv.Addr().Interface().(*[]bool)
-		v, changed := fastpathTV.DecSliceBoolV(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
+func (d *Decoder) fastpathDecSliceBoolR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]bool)
+		if v, changed := fastpathTV.DecSliceBoolV(*vp, !array, d); changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]bool)
-		fastpathTV.DecSliceBoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecSliceBoolV(rv2i(rv).([]bool), !array, d)
 	}
 }
 
-func (f fastpathT) DecSliceBoolX(vp *[]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceBoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecSliceBoolX(vp *[]bool, d *Decoder) {
+	if v, changed := f.DecSliceBoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d *Decoder) (_ []bool, changed bool) {
+func (_ fastpathT) DecSliceBoolV(v []bool, canChange bool, d *Decoder) (_ []bool, changed bool) {
 	dd := d.d
 
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -20030,19323 +17983,15052 @@ func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d *Dec
 		return v, changed
 	}
 
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange {
-				var xlen int
-				xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 1)
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]bool, xlen)
-					}
-				} else {
-					v = make([]bool, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]bool, xlen)
 			}
-			x2read = len(v)
+			changed = true
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			v[j] = dd.DecodeBool()
-		}
-		if xtrunc {
-			for ; j < containerLenS; j++ {
-				v = append(v, false)
-				slh.ElemContainerState(j)
-				v[j] = dd.DecodeBool()
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak()
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []bool{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]bool, 1, 4)
+			v = v[:containerLenS]
 			changed = true
 		}
-		j := 0
-		for ; !breakFound; j++ {
-			if j >= len(v) {
-				if canChange {
-					v = append(v, false)
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) {
-				v[j] = dd.DecodeBool()
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
 			} else {
-				d.swallow()
+				xlen = 8
 			}
-			breakFound = dd.CheckBreak()
+			v = make([]bool, xlen)
+			changed = true
 		}
-		if canChange && j < len(v) {
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, false)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			v[j] = dd.DecodeBool()
+		}
+	}
+	if canChange {
+		if j < len(v) {
 			v = v[:j]
 			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]bool, 0)
+			changed = true
 		}
 	}
 	slh.End()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]interface{})
-		v, changed := fastpathTV.DecMapIntfIntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]interface{})
+		if v, changed := fastpathTV.DecMapIntfIntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]interface{})
-		fastpathTV.DecMapIntfIntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), false, d)
 }
-func (f fastpathT) DecMapIntfIntfX(vp *map[interface{}]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfIntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfIntfX(vp *map[interface{}]interface{}, d *Decoder) {
+	if v, changed := f.DecMapIntfIntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, canChange bool,
 	d *Decoder) (_ map[interface{}]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 32)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
 		v = make(map[interface{}]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk interface{}
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]string)
-		v, changed := fastpathTV.DecMapIntfStringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]string)
+		if v, changed := fastpathTV.DecMapIntfStringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]string)
-		fastpathTV.DecMapIntfStringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfStringV(rv2i(rv).(map[interface{}]string), false, d)
 }
-func (f fastpathT) DecMapIntfStringX(vp *map[interface{}]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfStringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfStringX(vp *map[interface{}]string, d *Decoder) {
+	if v, changed := f.DecMapIntfStringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, canChange bool,
 	d *Decoder) (_ map[interface{}]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 32)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
 		v = make(map[interface{}]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]uint)
-		v, changed := fastpathTV.DecMapIntfUintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint)
+		if v, changed := fastpathTV.DecMapIntfUintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]uint)
-		fastpathTV.DecMapIntfUintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfUintV(rv2i(rv).(map[interface{}]uint), false, d)
 }
-func (f fastpathT) DecMapIntfUintX(vp *map[interface{}]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfUintX(vp *map[interface{}]uint, d *Decoder) {
+	if v, changed := f.DecMapIntfUintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, canChange bool,
 	d *Decoder) (_ map[interface{}]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[interface{}]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]uint8)
-		v, changed := fastpathTV.DecMapIntfUint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint8)
+		if v, changed := fastpathTV.DecMapIntfUint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]uint8)
-		fastpathTV.DecMapIntfUint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), false, d)
 }
-func (f fastpathT) DecMapIntfUint8X(vp *map[interface{}]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfUint8X(vp *map[interface{}]uint8, d *Decoder) {
+	if v, changed := f.DecMapIntfUint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, canChange bool,
 	d *Decoder) (_ map[interface{}]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[interface{}]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]uint16)
-		v, changed := fastpathTV.DecMapIntfUint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint16)
+		if v, changed := fastpathTV.DecMapIntfUint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]uint16)
-		fastpathTV.DecMapIntfUint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), false, d)
 }
-func (f fastpathT) DecMapIntfUint16X(vp *map[interface{}]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfUint16X(vp *map[interface{}]uint16, d *Decoder) {
+	if v, changed := f.DecMapIntfUint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, canChange bool,
 	d *Decoder) (_ map[interface{}]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
 		v = make(map[interface{}]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]uint32)
-		v, changed := fastpathTV.DecMapIntfUint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint32)
+		if v, changed := fastpathTV.DecMapIntfUint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]uint32)
-		fastpathTV.DecMapIntfUint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), false, d)
 }
-func (f fastpathT) DecMapIntfUint32X(vp *map[interface{}]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfUint32X(vp *map[interface{}]uint32, d *Decoder) {
+	if v, changed := f.DecMapIntfUint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, canChange bool,
 	d *Decoder) (_ map[interface{}]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[interface{}]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]uint64)
-		v, changed := fastpathTV.DecMapIntfUint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint64)
+		if v, changed := fastpathTV.DecMapIntfUint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]uint64)
-		fastpathTV.DecMapIntfUint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), false, d)
 }
-func (f fastpathT) DecMapIntfUint64X(vp *map[interface{}]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfUint64X(vp *map[interface{}]uint64, d *Decoder) {
+	if v, changed := f.DecMapIntfUint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, canChange bool,
 	d *Decoder) (_ map[interface{}]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[interface{}]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]uintptr)
-		v, changed := fastpathTV.DecMapIntfUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uintptr)
+		if v, changed := fastpathTV.DecMapIntfUintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]uintptr)
-		fastpathTV.DecMapIntfUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), false, d)
 }
-func (f fastpathT) DecMapIntfUintptrX(vp *map[interface{}]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfUintptrX(vp *map[interface{}]uintptr, d *Decoder) {
+	if v, changed := f.DecMapIntfUintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, canChange bool,
 	d *Decoder) (_ map[interface{}]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[interface{}]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]int)
-		v, changed := fastpathTV.DecMapIntfIntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int)
+		if v, changed := fastpathTV.DecMapIntfIntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]int)
-		fastpathTV.DecMapIntfIntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfIntV(rv2i(rv).(map[interface{}]int), false, d)
 }
-func (f fastpathT) DecMapIntfIntX(vp *map[interface{}]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfIntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfIntX(vp *map[interface{}]int, d *Decoder) {
+	if v, changed := f.DecMapIntfIntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, canChange bool,
 	d *Decoder) (_ map[interface{}]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[interface{}]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]int8)
-		v, changed := fastpathTV.DecMapIntfInt8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int8)
+		if v, changed := fastpathTV.DecMapIntfInt8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]int8)
-		fastpathTV.DecMapIntfInt8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfInt8V(rv2i(rv).(map[interface{}]int8), false, d)
 }
-func (f fastpathT) DecMapIntfInt8X(vp *map[interface{}]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfInt8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfInt8X(vp *map[interface{}]int8, d *Decoder) {
+	if v, changed := f.DecMapIntfInt8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, canChange bool,
 	d *Decoder) (_ map[interface{}]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[interface{}]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]int16)
-		v, changed := fastpathTV.DecMapIntfInt16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int16)
+		if v, changed := fastpathTV.DecMapIntfInt16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]int16)
-		fastpathTV.DecMapIntfInt16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfInt16V(rv2i(rv).(map[interface{}]int16), false, d)
 }
-func (f fastpathT) DecMapIntfInt16X(vp *map[interface{}]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfInt16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfInt16X(vp *map[interface{}]int16, d *Decoder) {
+	if v, changed := f.DecMapIntfInt16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, canChange bool,
 	d *Decoder) (_ map[interface{}]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
 		v = make(map[interface{}]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]int32)
-		v, changed := fastpathTV.DecMapIntfInt32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int32)
+		if v, changed := fastpathTV.DecMapIntfInt32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]int32)
-		fastpathTV.DecMapIntfInt32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfInt32V(rv2i(rv).(map[interface{}]int32), false, d)
 }
-func (f fastpathT) DecMapIntfInt32X(vp *map[interface{}]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfInt32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfInt32X(vp *map[interface{}]int32, d *Decoder) {
+	if v, changed := f.DecMapIntfInt32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, canChange bool,
 	d *Decoder) (_ map[interface{}]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[interface{}]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]int64)
-		v, changed := fastpathTV.DecMapIntfInt64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int64)
+		if v, changed := fastpathTV.DecMapIntfInt64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]int64)
-		fastpathTV.DecMapIntfInt64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfInt64V(rv2i(rv).(map[interface{}]int64), false, d)
 }
-func (f fastpathT) DecMapIntfInt64X(vp *map[interface{}]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfInt64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfInt64X(vp *map[interface{}]int64, d *Decoder) {
+	if v, changed := f.DecMapIntfInt64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, canChange bool,
 	d *Decoder) (_ map[interface{}]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[interface{}]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]float32)
-		v, changed := fastpathTV.DecMapIntfFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]float32)
+		if v, changed := fastpathTV.DecMapIntfFloat32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]float32)
-		fastpathTV.DecMapIntfFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), false, d)
 }
-func (f fastpathT) DecMapIntfFloat32X(vp *map[interface{}]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfFloat32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfFloat32X(vp *map[interface{}]float32, d *Decoder) {
+	if v, changed := f.DecMapIntfFloat32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, canChange bool,
 	d *Decoder) (_ map[interface{}]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[interface{}]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]float64)
-		v, changed := fastpathTV.DecMapIntfFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]float64)
+		if v, changed := fastpathTV.DecMapIntfFloat64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]float64)
-		fastpathTV.DecMapIntfFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), false, d)
 }
-func (f fastpathT) DecMapIntfFloat64X(vp *map[interface{}]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfFloat64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfFloat64X(vp *map[interface{}]float64, d *Decoder) {
+	if v, changed := f.DecMapIntfFloat64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, canChange bool,
 	d *Decoder) (_ map[interface{}]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[interface{}]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[interface{}]bool)
-		v, changed := fastpathTV.DecMapIntfBoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]bool)
+		if v, changed := fastpathTV.DecMapIntfBoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[interface{}]bool)
-		fastpathTV.DecMapIntfBoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntfBoolV(rv2i(rv).(map[interface{}]bool), false, d)
 }
-func (f fastpathT) DecMapIntfBoolX(vp *map[interface{}]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfBoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntfBoolX(vp *map[interface{}]bool, d *Decoder) {
+	if v, changed := f.DecMapIntfBoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, canChange bool,
 	d *Decoder) (_ map[interface{}]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[interface{}]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk interface{}
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = nil
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = nil
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv)
+		}
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]interface{})
-		v, changed := fastpathTV.DecMapStringIntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]interface{})
+		if v, changed := fastpathTV.DecMapStringIntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]interface{})
-		fastpathTV.DecMapStringIntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringIntfV(rv2i(rv).(map[string]interface{}), false, d)
 }
-func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringIntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, d *Decoder) {
+	if v, changed := f.DecMapStringIntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, canChange bool,
 	d *Decoder) (_ map[string]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 32)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
 		v = make(map[string]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk string
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]string)
-		v, changed := fastpathTV.DecMapStringStringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]string)
+		if v, changed := fastpathTV.DecMapStringStringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]string)
-		fastpathTV.DecMapStringStringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringStringV(rv2i(rv).(map[string]string), false, d)
 }
-func (f fastpathT) DecMapStringStringX(vp *map[string]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringStringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringStringX(vp *map[string]string, d *Decoder) {
+	if v, changed := f.DecMapStringStringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringStringV(v map[string]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringStringV(v map[string]string, canChange bool,
 	d *Decoder) (_ map[string]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 32)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
 		v = make(map[string]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]uint)
-		v, changed := fastpathTV.DecMapStringUintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint)
+		if v, changed := fastpathTV.DecMapStringUintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]uint)
-		fastpathTV.DecMapStringUintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringUintV(rv2i(rv).(map[string]uint), false, d)
 }
-func (f fastpathT) DecMapStringUintX(vp *map[string]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringUintX(vp *map[string]uint, d *Decoder) {
+	if v, changed := f.DecMapStringUintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUintV(v map[string]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUintV(v map[string]uint, canChange bool,
 	d *Decoder) (_ map[string]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[string]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]uint8)
-		v, changed := fastpathTV.DecMapStringUint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint8)
+		if v, changed := fastpathTV.DecMapStringUint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]uint8)
-		fastpathTV.DecMapStringUint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringUint8V(rv2i(rv).(map[string]uint8), false, d)
 }
-func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, d *Decoder) {
+	if v, changed := f.DecMapStringUint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, canChange bool,
 	d *Decoder) (_ map[string]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[string]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]uint16)
-		v, changed := fastpathTV.DecMapStringUint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint16)
+		if v, changed := fastpathTV.DecMapStringUint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]uint16)
-		fastpathTV.DecMapStringUint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringUint16V(rv2i(rv).(map[string]uint16), false, d)
 }
-func (f fastpathT) DecMapStringUint16X(vp *map[string]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringUint16X(vp *map[string]uint16, d *Decoder) {
+	if v, changed := f.DecMapStringUint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, canChange bool,
 	d *Decoder) (_ map[string]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
 		v = make(map[string]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]uint32)
-		v, changed := fastpathTV.DecMapStringUint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint32)
+		if v, changed := fastpathTV.DecMapStringUint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]uint32)
-		fastpathTV.DecMapStringUint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringUint32V(rv2i(rv).(map[string]uint32), false, d)
 }
-func (f fastpathT) DecMapStringUint32X(vp *map[string]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringUint32X(vp *map[string]uint32, d *Decoder) {
+	if v, changed := f.DecMapStringUint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, canChange bool,
 	d *Decoder) (_ map[string]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[string]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]uint64)
-		v, changed := fastpathTV.DecMapStringUint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint64)
+		if v, changed := fastpathTV.DecMapStringUint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]uint64)
-		fastpathTV.DecMapStringUint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringUint64V(rv2i(rv).(map[string]uint64), false, d)
 }
-func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, d *Decoder) {
+	if v, changed := f.DecMapStringUint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, canChange bool,
 	d *Decoder) (_ map[string]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[string]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]uintptr)
-		v, changed := fastpathTV.DecMapStringUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uintptr)
+		if v, changed := fastpathTV.DecMapStringUintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]uintptr)
-		fastpathTV.DecMapStringUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringUintptrV(rv2i(rv).(map[string]uintptr), false, d)
 }
-func (f fastpathT) DecMapStringUintptrX(vp *map[string]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringUintptrX(vp *map[string]uintptr, d *Decoder) {
+	if v, changed := f.DecMapStringUintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, canChange bool,
 	d *Decoder) (_ map[string]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[string]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]int)
-		v, changed := fastpathTV.DecMapStringIntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int)
+		if v, changed := fastpathTV.DecMapStringIntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]int)
-		fastpathTV.DecMapStringIntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringIntV(rv2i(rv).(map[string]int), false, d)
 }
-func (f fastpathT) DecMapStringIntX(vp *map[string]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringIntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringIntX(vp *map[string]int, d *Decoder) {
+	if v, changed := f.DecMapStringIntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringIntV(v map[string]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringIntV(v map[string]int, canChange bool,
 	d *Decoder) (_ map[string]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[string]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]int8)
-		v, changed := fastpathTV.DecMapStringInt8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int8)
+		if v, changed := fastpathTV.DecMapStringInt8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]int8)
-		fastpathTV.DecMapStringInt8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringInt8V(rv2i(rv).(map[string]int8), false, d)
 }
-func (f fastpathT) DecMapStringInt8X(vp *map[string]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringInt8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringInt8X(vp *map[string]int8, d *Decoder) {
+	if v, changed := f.DecMapStringInt8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringInt8V(v map[string]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringInt8V(v map[string]int8, canChange bool,
 	d *Decoder) (_ map[string]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[string]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]int16)
-		v, changed := fastpathTV.DecMapStringInt16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int16)
+		if v, changed := fastpathTV.DecMapStringInt16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]int16)
-		fastpathTV.DecMapStringInt16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringInt16V(rv2i(rv).(map[string]int16), false, d)
 }
-func (f fastpathT) DecMapStringInt16X(vp *map[string]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringInt16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringInt16X(vp *map[string]int16, d *Decoder) {
+	if v, changed := f.DecMapStringInt16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringInt16V(v map[string]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringInt16V(v map[string]int16, canChange bool,
 	d *Decoder) (_ map[string]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
 		v = make(map[string]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]int32)
-		v, changed := fastpathTV.DecMapStringInt32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int32)
+		if v, changed := fastpathTV.DecMapStringInt32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]int32)
-		fastpathTV.DecMapStringInt32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringInt32V(rv2i(rv).(map[string]int32), false, d)
 }
-func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringInt32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, d *Decoder) {
+	if v, changed := f.DecMapStringInt32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringInt32V(v map[string]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringInt32V(v map[string]int32, canChange bool,
 	d *Decoder) (_ map[string]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[string]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]int64)
-		v, changed := fastpathTV.DecMapStringInt64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int64)
+		if v, changed := fastpathTV.DecMapStringInt64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]int64)
-		fastpathTV.DecMapStringInt64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringInt64V(rv2i(rv).(map[string]int64), false, d)
 }
-func (f fastpathT) DecMapStringInt64X(vp *map[string]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringInt64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringInt64X(vp *map[string]int64, d *Decoder) {
+	if v, changed := f.DecMapStringInt64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringInt64V(v map[string]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringInt64V(v map[string]int64, canChange bool,
 	d *Decoder) (_ map[string]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[string]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]float32)
-		v, changed := fastpathTV.DecMapStringFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]float32)
+		if v, changed := fastpathTV.DecMapStringFloat32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]float32)
-		fastpathTV.DecMapStringFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringFloat32V(rv2i(rv).(map[string]float32), false, d)
 }
-func (f fastpathT) DecMapStringFloat32X(vp *map[string]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringFloat32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringFloat32X(vp *map[string]float32, d *Decoder) {
+	if v, changed := f.DecMapStringFloat32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, canChange bool,
 	d *Decoder) (_ map[string]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[string]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]float64)
-		v, changed := fastpathTV.DecMapStringFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]float64)
+		if v, changed := fastpathTV.DecMapStringFloat64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]float64)
-		fastpathTV.DecMapStringFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringFloat64V(rv2i(rv).(map[string]float64), false, d)
 }
-func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringFloat64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, d *Decoder) {
+	if v, changed := f.DecMapStringFloat64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, canChange bool,
 	d *Decoder) (_ map[string]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[string]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[string]bool)
-		v, changed := fastpathTV.DecMapStringBoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]bool)
+		if v, changed := fastpathTV.DecMapStringBoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[string]bool)
-		fastpathTV.DecMapStringBoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapStringBoolV(rv2i(rv).(map[string]bool), false, d)
 }
-func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringBoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, d *Decoder) {
+	if v, changed := f.DecMapStringBoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringBoolV(v map[string]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringBoolV(v map[string]bool, canChange bool,
 	d *Decoder) (_ map[string]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[string]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk string
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeString()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]interface{})
-		v, changed := fastpathTV.DecMapFloat32IntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]interface{})
+		if v, changed := fastpathTV.DecMapFloat32IntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]interface{})
-		fastpathTV.DecMapFloat32IntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), false, d)
 }
-func (f fastpathT) DecMapFloat32IntfX(vp *map[float32]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32IntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32IntfX(vp *map[float32]interface{}, d *Decoder) {
+	if v, changed := f.DecMapFloat32IntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, canChange bool,
 	d *Decoder) (_ map[float32]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[float32]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk float32
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]string)
-		v, changed := fastpathTV.DecMapFloat32StringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]string)
+		if v, changed := fastpathTV.DecMapFloat32StringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]string)
-		fastpathTV.DecMapFloat32StringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32StringV(rv2i(rv).(map[float32]string), false, d)
 }
-func (f fastpathT) DecMapFloat32StringX(vp *map[float32]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32StringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32StringX(vp *map[float32]string, d *Decoder) {
+	if v, changed := f.DecMapFloat32StringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, canChange bool,
 	d *Decoder) (_ map[float32]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[float32]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]uint)
-		v, changed := fastpathTV.DecMapFloat32UintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint)
+		if v, changed := fastpathTV.DecMapFloat32UintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]uint)
-		fastpathTV.DecMapFloat32UintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32UintV(rv2i(rv).(map[float32]uint), false, d)
 }
-func (f fastpathT) DecMapFloat32UintX(vp *map[float32]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32UintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32UintX(vp *map[float32]uint, d *Decoder) {
+	if v, changed := f.DecMapFloat32UintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, canChange bool,
 	d *Decoder) (_ map[float32]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[float32]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]uint8)
-		v, changed := fastpathTV.DecMapFloat32Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint8)
+		if v, changed := fastpathTV.DecMapFloat32Uint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]uint8)
-		fastpathTV.DecMapFloat32Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), false, d)
 }
-func (f fastpathT) DecMapFloat32Uint8X(vp *map[float32]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Uint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32Uint8X(vp *map[float32]uint8, d *Decoder) {
+	if v, changed := f.DecMapFloat32Uint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, canChange bool,
 	d *Decoder) (_ map[float32]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[float32]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]uint16)
-		v, changed := fastpathTV.DecMapFloat32Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint16)
+		if v, changed := fastpathTV.DecMapFloat32Uint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]uint16)
-		fastpathTV.DecMapFloat32Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), false, d)
 }
-func (f fastpathT) DecMapFloat32Uint16X(vp *map[float32]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Uint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32Uint16X(vp *map[float32]uint16, d *Decoder) {
+	if v, changed := f.DecMapFloat32Uint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, canChange bool,
 	d *Decoder) (_ map[float32]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[float32]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]uint32)
-		v, changed := fastpathTV.DecMapFloat32Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint32)
+		if v, changed := fastpathTV.DecMapFloat32Uint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]uint32)
-		fastpathTV.DecMapFloat32Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), false, d)
 }
-func (f fastpathT) DecMapFloat32Uint32X(vp *map[float32]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Uint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32Uint32X(vp *map[float32]uint32, d *Decoder) {
+	if v, changed := f.DecMapFloat32Uint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, canChange bool,
 	d *Decoder) (_ map[float32]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
 		v = make(map[float32]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]uint64)
-		v, changed := fastpathTV.DecMapFloat32Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint64)
+		if v, changed := fastpathTV.DecMapFloat32Uint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]uint64)
-		fastpathTV.DecMapFloat32Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), false, d)
 }
-func (f fastpathT) DecMapFloat32Uint64X(vp *map[float32]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Uint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32Uint64X(vp *map[float32]uint64, d *Decoder) {
+	if v, changed := f.DecMapFloat32Uint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, canChange bool,
 	d *Decoder) (_ map[float32]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[float32]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]uintptr)
-		v, changed := fastpathTV.DecMapFloat32UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uintptr)
+		if v, changed := fastpathTV.DecMapFloat32UintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]uintptr)
-		fastpathTV.DecMapFloat32UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), false, d)
 }
-func (f fastpathT) DecMapFloat32UintptrX(vp *map[float32]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32UintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32UintptrX(vp *map[float32]uintptr, d *Decoder) {
+	if v, changed := f.DecMapFloat32UintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, canChange bool,
 	d *Decoder) (_ map[float32]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[float32]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]int)
-		v, changed := fastpathTV.DecMapFloat32IntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int)
+		if v, changed := fastpathTV.DecMapFloat32IntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]int)
-		fastpathTV.DecMapFloat32IntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32IntV(rv2i(rv).(map[float32]int), false, d)
 }
-func (f fastpathT) DecMapFloat32IntX(vp *map[float32]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32IntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32IntX(vp *map[float32]int, d *Decoder) {
+	if v, changed := f.DecMapFloat32IntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, canChange bool,
 	d *Decoder) (_ map[float32]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[float32]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]int8)
-		v, changed := fastpathTV.DecMapFloat32Int8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int8)
+		if v, changed := fastpathTV.DecMapFloat32Int8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]int8)
-		fastpathTV.DecMapFloat32Int8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32Int8V(rv2i(rv).(map[float32]int8), false, d)
 }
-func (f fastpathT) DecMapFloat32Int8X(vp *map[float32]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Int8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32Int8X(vp *map[float32]int8, d *Decoder) {
+	if v, changed := f.DecMapFloat32Int8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, canChange bool,
 	d *Decoder) (_ map[float32]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[float32]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]int16)
-		v, changed := fastpathTV.DecMapFloat32Int16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int16)
+		if v, changed := fastpathTV.DecMapFloat32Int16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]int16)
-		fastpathTV.DecMapFloat32Int16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32Int16V(rv2i(rv).(map[float32]int16), false, d)
 }
-func (f fastpathT) DecMapFloat32Int16X(vp *map[float32]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Int16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32Int16X(vp *map[float32]int16, d *Decoder) {
+	if v, changed := f.DecMapFloat32Int16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, canChange bool,
 	d *Decoder) (_ map[float32]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[float32]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]int32)
-		v, changed := fastpathTV.DecMapFloat32Int32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int32)
+		if v, changed := fastpathTV.DecMapFloat32Int32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]int32)
-		fastpathTV.DecMapFloat32Int32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32Int32V(rv2i(rv).(map[float32]int32), false, d)
 }
-func (f fastpathT) DecMapFloat32Int32X(vp *map[float32]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Int32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32Int32X(vp *map[float32]int32, d *Decoder) {
+	if v, changed := f.DecMapFloat32Int32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, canChange bool,
 	d *Decoder) (_ map[float32]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
 		v = make(map[float32]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]int64)
-		v, changed := fastpathTV.DecMapFloat32Int64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int64)
+		if v, changed := fastpathTV.DecMapFloat32Int64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]int64)
-		fastpathTV.DecMapFloat32Int64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32Int64V(rv2i(rv).(map[float32]int64), false, d)
 }
-func (f fastpathT) DecMapFloat32Int64X(vp *map[float32]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Int64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32Int64X(vp *map[float32]int64, d *Decoder) {
+	if v, changed := f.DecMapFloat32Int64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, canChange bool,
 	d *Decoder) (_ map[float32]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[float32]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]float32)
-		v, changed := fastpathTV.DecMapFloat32Float32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]float32)
+		if v, changed := fastpathTV.DecMapFloat32Float32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]float32)
-		fastpathTV.DecMapFloat32Float32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32Float32V(rv2i(rv).(map[float32]float32), false, d)
 }
-func (f fastpathT) DecMapFloat32Float32X(vp *map[float32]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Float32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32Float32X(vp *map[float32]float32, d *Decoder) {
+	if v, changed := f.DecMapFloat32Float32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, canChange bool,
 	d *Decoder) (_ map[float32]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
 		v = make(map[float32]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]float64)
-		v, changed := fastpathTV.DecMapFloat32Float64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]float64)
+		if v, changed := fastpathTV.DecMapFloat32Float64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]float64)
-		fastpathTV.DecMapFloat32Float64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32Float64V(rv2i(rv).(map[float32]float64), false, d)
 }
-func (f fastpathT) DecMapFloat32Float64X(vp *map[float32]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Float64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32Float64X(vp *map[float32]float64, d *Decoder) {
+	if v, changed := f.DecMapFloat32Float64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, canChange bool,
 	d *Decoder) (_ map[float32]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[float32]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float32]bool)
-		v, changed := fastpathTV.DecMapFloat32BoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]bool)
+		if v, changed := fastpathTV.DecMapFloat32BoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float32]bool)
-		fastpathTV.DecMapFloat32BoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat32BoolV(rv2i(rv).(map[float32]bool), false, d)
 }
-func (f fastpathT) DecMapFloat32BoolX(vp *map[float32]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32BoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat32BoolX(vp *map[float32]bool, d *Decoder) {
+	if v, changed := f.DecMapFloat32BoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, canChange bool,
 	d *Decoder) (_ map[float32]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[float32]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float32
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = float32(dd.DecodeFloat(true))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = float32(dd.DecodeFloat(true))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]interface{})
-		v, changed := fastpathTV.DecMapFloat64IntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]interface{})
+		if v, changed := fastpathTV.DecMapFloat64IntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]interface{})
-		fastpathTV.DecMapFloat64IntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), false, d)
 }
-func (f fastpathT) DecMapFloat64IntfX(vp *map[float64]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64IntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64IntfX(vp *map[float64]interface{}, d *Decoder) {
+	if v, changed := f.DecMapFloat64IntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, canChange bool,
 	d *Decoder) (_ map[float64]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[float64]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk float64
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]string)
-		v, changed := fastpathTV.DecMapFloat64StringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]string)
+		if v, changed := fastpathTV.DecMapFloat64StringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]string)
-		fastpathTV.DecMapFloat64StringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64StringV(rv2i(rv).(map[float64]string), false, d)
 }
-func (f fastpathT) DecMapFloat64StringX(vp *map[float64]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64StringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64StringX(vp *map[float64]string, d *Decoder) {
+	if v, changed := f.DecMapFloat64StringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, canChange bool,
 	d *Decoder) (_ map[float64]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[float64]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]uint)
-		v, changed := fastpathTV.DecMapFloat64UintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint)
+		if v, changed := fastpathTV.DecMapFloat64UintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]uint)
-		fastpathTV.DecMapFloat64UintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64UintV(rv2i(rv).(map[float64]uint), false, d)
 }
-func (f fastpathT) DecMapFloat64UintX(vp *map[float64]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64UintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64UintX(vp *map[float64]uint, d *Decoder) {
+	if v, changed := f.DecMapFloat64UintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, canChange bool,
 	d *Decoder) (_ map[float64]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[float64]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]uint8)
-		v, changed := fastpathTV.DecMapFloat64Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint8)
+		if v, changed := fastpathTV.DecMapFloat64Uint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]uint8)
-		fastpathTV.DecMapFloat64Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), false, d)
 }
-func (f fastpathT) DecMapFloat64Uint8X(vp *map[float64]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Uint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64Uint8X(vp *map[float64]uint8, d *Decoder) {
+	if v, changed := f.DecMapFloat64Uint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, canChange bool,
 	d *Decoder) (_ map[float64]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[float64]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]uint16)
-		v, changed := fastpathTV.DecMapFloat64Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint16)
+		if v, changed := fastpathTV.DecMapFloat64Uint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]uint16)
-		fastpathTV.DecMapFloat64Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), false, d)
 }
-func (f fastpathT) DecMapFloat64Uint16X(vp *map[float64]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Uint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64Uint16X(vp *map[float64]uint16, d *Decoder) {
+	if v, changed := f.DecMapFloat64Uint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, canChange bool,
 	d *Decoder) (_ map[float64]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[float64]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]uint32)
-		v, changed := fastpathTV.DecMapFloat64Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint32)
+		if v, changed := fastpathTV.DecMapFloat64Uint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]uint32)
-		fastpathTV.DecMapFloat64Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), false, d)
 }
-func (f fastpathT) DecMapFloat64Uint32X(vp *map[float64]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Uint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64Uint32X(vp *map[float64]uint32, d *Decoder) {
+	if v, changed := f.DecMapFloat64Uint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, canChange bool,
 	d *Decoder) (_ map[float64]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[float64]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]uint64)
-		v, changed := fastpathTV.DecMapFloat64Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint64)
+		if v, changed := fastpathTV.DecMapFloat64Uint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]uint64)
-		fastpathTV.DecMapFloat64Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), false, d)
 }
-func (f fastpathT) DecMapFloat64Uint64X(vp *map[float64]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Uint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64Uint64X(vp *map[float64]uint64, d *Decoder) {
+	if v, changed := f.DecMapFloat64Uint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, canChange bool,
 	d *Decoder) (_ map[float64]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[float64]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]uintptr)
-		v, changed := fastpathTV.DecMapFloat64UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uintptr)
+		if v, changed := fastpathTV.DecMapFloat64UintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]uintptr)
-		fastpathTV.DecMapFloat64UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), false, d)
 }
-func (f fastpathT) DecMapFloat64UintptrX(vp *map[float64]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64UintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64UintptrX(vp *map[float64]uintptr, d *Decoder) {
+	if v, changed := f.DecMapFloat64UintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, canChange bool,
 	d *Decoder) (_ map[float64]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[float64]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]int)
-		v, changed := fastpathTV.DecMapFloat64IntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int)
+		if v, changed := fastpathTV.DecMapFloat64IntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]int)
-		fastpathTV.DecMapFloat64IntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64IntV(rv2i(rv).(map[float64]int), false, d)
 }
-func (f fastpathT) DecMapFloat64IntX(vp *map[float64]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64IntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64IntX(vp *map[float64]int, d *Decoder) {
+	if v, changed := f.DecMapFloat64IntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, canChange bool,
 	d *Decoder) (_ map[float64]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[float64]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]int8)
-		v, changed := fastpathTV.DecMapFloat64Int8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int8)
+		if v, changed := fastpathTV.DecMapFloat64Int8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]int8)
-		fastpathTV.DecMapFloat64Int8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64Int8V(rv2i(rv).(map[float64]int8), false, d)
 }
-func (f fastpathT) DecMapFloat64Int8X(vp *map[float64]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Int8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64Int8X(vp *map[float64]int8, d *Decoder) {
+	if v, changed := f.DecMapFloat64Int8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, canChange bool,
 	d *Decoder) (_ map[float64]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[float64]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]int16)
-		v, changed := fastpathTV.DecMapFloat64Int16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int16)
+		if v, changed := fastpathTV.DecMapFloat64Int16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]int16)
-		fastpathTV.DecMapFloat64Int16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64Int16V(rv2i(rv).(map[float64]int16), false, d)
 }
-func (f fastpathT) DecMapFloat64Int16X(vp *map[float64]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Int16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64Int16X(vp *map[float64]int16, d *Decoder) {
+	if v, changed := f.DecMapFloat64Int16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, canChange bool,
 	d *Decoder) (_ map[float64]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[float64]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]int32)
-		v, changed := fastpathTV.DecMapFloat64Int32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int32)
+		if v, changed := fastpathTV.DecMapFloat64Int32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]int32)
-		fastpathTV.DecMapFloat64Int32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64Int32V(rv2i(rv).(map[float64]int32), false, d)
 }
-func (f fastpathT) DecMapFloat64Int32X(vp *map[float64]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Int32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64Int32X(vp *map[float64]int32, d *Decoder) {
+	if v, changed := f.DecMapFloat64Int32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, canChange bool,
 	d *Decoder) (_ map[float64]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[float64]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]int64)
-		v, changed := fastpathTV.DecMapFloat64Int64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int64)
+		if v, changed := fastpathTV.DecMapFloat64Int64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]int64)
-		fastpathTV.DecMapFloat64Int64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64Int64V(rv2i(rv).(map[float64]int64), false, d)
 }
-func (f fastpathT) DecMapFloat64Int64X(vp *map[float64]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Int64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64Int64X(vp *map[float64]int64, d *Decoder) {
+	if v, changed := f.DecMapFloat64Int64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, canChange bool,
 	d *Decoder) (_ map[float64]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[float64]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]float32)
-		v, changed := fastpathTV.DecMapFloat64Float32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]float32)
+		if v, changed := fastpathTV.DecMapFloat64Float32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]float32)
-		fastpathTV.DecMapFloat64Float32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64Float32V(rv2i(rv).(map[float64]float32), false, d)
 }
-func (f fastpathT) DecMapFloat64Float32X(vp *map[float64]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Float32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64Float32X(vp *map[float64]float32, d *Decoder) {
+	if v, changed := f.DecMapFloat64Float32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, canChange bool,
 	d *Decoder) (_ map[float64]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[float64]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]float64)
-		v, changed := fastpathTV.DecMapFloat64Float64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]float64)
+		if v, changed := fastpathTV.DecMapFloat64Float64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]float64)
-		fastpathTV.DecMapFloat64Float64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64Float64V(rv2i(rv).(map[float64]float64), false, d)
 }
-func (f fastpathT) DecMapFloat64Float64X(vp *map[float64]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Float64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64Float64X(vp *map[float64]float64, d *Decoder) {
+	if v, changed := f.DecMapFloat64Float64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, canChange bool,
 	d *Decoder) (_ map[float64]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[float64]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[float64]bool)
-		v, changed := fastpathTV.DecMapFloat64BoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]bool)
+		if v, changed := fastpathTV.DecMapFloat64BoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[float64]bool)
-		fastpathTV.DecMapFloat64BoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapFloat64BoolV(rv2i(rv).(map[float64]bool), false, d)
 }
-func (f fastpathT) DecMapFloat64BoolX(vp *map[float64]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64BoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapFloat64BoolX(vp *map[float64]bool, d *Decoder) {
+	if v, changed := f.DecMapFloat64BoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, canChange bool,
 	d *Decoder) (_ map[float64]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[float64]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk float64
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeFloat(false)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeFloat(false)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]interface{})
-		v, changed := fastpathTV.DecMapUintIntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]interface{})
+		if v, changed := fastpathTV.DecMapUintIntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]interface{})
-		fastpathTV.DecMapUintIntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintIntfV(rv2i(rv).(map[uint]interface{}), false, d)
 }
-func (f fastpathT) DecMapUintIntfX(vp *map[uint]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintIntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintIntfX(vp *map[uint]interface{}, d *Decoder) {
+	if v, changed := f.DecMapUintIntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, canChange bool,
 	d *Decoder) (_ map[uint]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[uint]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uint
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]string)
-		v, changed := fastpathTV.DecMapUintStringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]string)
+		if v, changed := fastpathTV.DecMapUintStringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]string)
-		fastpathTV.DecMapUintStringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintStringV(rv2i(rv).(map[uint]string), false, d)
 }
-func (f fastpathT) DecMapUintStringX(vp *map[uint]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintStringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintStringX(vp *map[uint]string, d *Decoder) {
+	if v, changed := f.DecMapUintStringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintStringV(v map[uint]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintStringV(v map[uint]string, canChange bool,
 	d *Decoder) (_ map[uint]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[uint]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]uint)
-		v, changed := fastpathTV.DecMapUintUintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint)
+		if v, changed := fastpathTV.DecMapUintUintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]uint)
-		fastpathTV.DecMapUintUintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintUintV(rv2i(rv).(map[uint]uint), false, d)
 }
-func (f fastpathT) DecMapUintUintX(vp *map[uint]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintUintX(vp *map[uint]uint, d *Decoder) {
+	if v, changed := f.DecMapUintUintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUintV(v map[uint]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUintV(v map[uint]uint, canChange bool,
 	d *Decoder) (_ map[uint]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]uint8)
-		v, changed := fastpathTV.DecMapUintUint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint8)
+		if v, changed := fastpathTV.DecMapUintUint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]uint8)
-		fastpathTV.DecMapUintUint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintUint8V(rv2i(rv).(map[uint]uint8), false, d)
 }
-func (f fastpathT) DecMapUintUint8X(vp *map[uint]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintUint8X(vp *map[uint]uint8, d *Decoder) {
+	if v, changed := f.DecMapUintUint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, canChange bool,
 	d *Decoder) (_ map[uint]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]uint16)
-		v, changed := fastpathTV.DecMapUintUint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint16)
+		if v, changed := fastpathTV.DecMapUintUint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]uint16)
-		fastpathTV.DecMapUintUint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintUint16V(rv2i(rv).(map[uint]uint16), false, d)
 }
-func (f fastpathT) DecMapUintUint16X(vp *map[uint]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintUint16X(vp *map[uint]uint16, d *Decoder) {
+	if v, changed := f.DecMapUintUint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, canChange bool,
 	d *Decoder) (_ map[uint]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uint]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]uint32)
-		v, changed := fastpathTV.DecMapUintUint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint32)
+		if v, changed := fastpathTV.DecMapUintUint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]uint32)
-		fastpathTV.DecMapUintUint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintUint32V(rv2i(rv).(map[uint]uint32), false, d)
 }
-func (f fastpathT) DecMapUintUint32X(vp *map[uint]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintUint32X(vp *map[uint]uint32, d *Decoder) {
+	if v, changed := f.DecMapUintUint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, canChange bool,
 	d *Decoder) (_ map[uint]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]uint64)
-		v, changed := fastpathTV.DecMapUintUint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint64)
+		if v, changed := fastpathTV.DecMapUintUint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]uint64)
-		fastpathTV.DecMapUintUint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintUint64V(rv2i(rv).(map[uint]uint64), false, d)
 }
-func (f fastpathT) DecMapUintUint64X(vp *map[uint]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintUint64X(vp *map[uint]uint64, d *Decoder) {
+	if v, changed := f.DecMapUintUint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, canChange bool,
 	d *Decoder) (_ map[uint]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]uintptr)
-		v, changed := fastpathTV.DecMapUintUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uintptr)
+		if v, changed := fastpathTV.DecMapUintUintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]uintptr)
-		fastpathTV.DecMapUintUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintUintptrV(rv2i(rv).(map[uint]uintptr), false, d)
 }
-func (f fastpathT) DecMapUintUintptrX(vp *map[uint]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintUintptrX(vp *map[uint]uintptr, d *Decoder) {
+	if v, changed := f.DecMapUintUintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, canChange bool,
 	d *Decoder) (_ map[uint]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]int)
-		v, changed := fastpathTV.DecMapUintIntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int)
+		if v, changed := fastpathTV.DecMapUintIntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]int)
-		fastpathTV.DecMapUintIntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintIntV(rv2i(rv).(map[uint]int), false, d)
 }
-func (f fastpathT) DecMapUintIntX(vp *map[uint]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintIntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintIntX(vp *map[uint]int, d *Decoder) {
+	if v, changed := f.DecMapUintIntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintIntV(v map[uint]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintIntV(v map[uint]int, canChange bool,
 	d *Decoder) (_ map[uint]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]int8)
-		v, changed := fastpathTV.DecMapUintInt8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int8)
+		if v, changed := fastpathTV.DecMapUintInt8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]int8)
-		fastpathTV.DecMapUintInt8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintInt8V(rv2i(rv).(map[uint]int8), false, d)
 }
-func (f fastpathT) DecMapUintInt8X(vp *map[uint]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintInt8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintInt8X(vp *map[uint]int8, d *Decoder) {
+	if v, changed := f.DecMapUintInt8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, canChange bool,
 	d *Decoder) (_ map[uint]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]int16)
-		v, changed := fastpathTV.DecMapUintInt16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int16)
+		if v, changed := fastpathTV.DecMapUintInt16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]int16)
-		fastpathTV.DecMapUintInt16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintInt16V(rv2i(rv).(map[uint]int16), false, d)
 }
-func (f fastpathT) DecMapUintInt16X(vp *map[uint]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintInt16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintInt16X(vp *map[uint]int16, d *Decoder) {
+	if v, changed := f.DecMapUintInt16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, canChange bool,
 	d *Decoder) (_ map[uint]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uint]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]int32)
-		v, changed := fastpathTV.DecMapUintInt32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int32)
+		if v, changed := fastpathTV.DecMapUintInt32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]int32)
-		fastpathTV.DecMapUintInt32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintInt32V(rv2i(rv).(map[uint]int32), false, d)
 }
-func (f fastpathT) DecMapUintInt32X(vp *map[uint]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintInt32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintInt32X(vp *map[uint]int32, d *Decoder) {
+	if v, changed := f.DecMapUintInt32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, canChange bool,
 	d *Decoder) (_ map[uint]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]int64)
-		v, changed := fastpathTV.DecMapUintInt64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int64)
+		if v, changed := fastpathTV.DecMapUintInt64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]int64)
-		fastpathTV.DecMapUintInt64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintInt64V(rv2i(rv).(map[uint]int64), false, d)
 }
-func (f fastpathT) DecMapUintInt64X(vp *map[uint]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintInt64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintInt64X(vp *map[uint]int64, d *Decoder) {
+	if v, changed := f.DecMapUintInt64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, canChange bool,
 	d *Decoder) (_ map[uint]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]float32)
-		v, changed := fastpathTV.DecMapUintFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]float32)
+		if v, changed := fastpathTV.DecMapUintFloat32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]float32)
-		fastpathTV.DecMapUintFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintFloat32V(rv2i(rv).(map[uint]float32), false, d)
 }
-func (f fastpathT) DecMapUintFloat32X(vp *map[uint]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintFloat32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintFloat32X(vp *map[uint]float32, d *Decoder) {
+	if v, changed := f.DecMapUintFloat32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, canChange bool,
 	d *Decoder) (_ map[uint]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]float64)
-		v, changed := fastpathTV.DecMapUintFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]float64)
+		if v, changed := fastpathTV.DecMapUintFloat64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]float64)
-		fastpathTV.DecMapUintFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintFloat64V(rv2i(rv).(map[uint]float64), false, d)
 }
-func (f fastpathT) DecMapUintFloat64X(vp *map[uint]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintFloat64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintFloat64X(vp *map[uint]float64, d *Decoder) {
+	if v, changed := f.DecMapUintFloat64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, canChange bool,
 	d *Decoder) (_ map[uint]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint]bool)
-		v, changed := fastpathTV.DecMapUintBoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]bool)
+		if v, changed := fastpathTV.DecMapUintBoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint]bool)
-		fastpathTV.DecMapUintBoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintBoolV(rv2i(rv).(map[uint]bool), false, d)
 }
-func (f fastpathT) DecMapUintBoolX(vp *map[uint]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintBoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintBoolX(vp *map[uint]bool, d *Decoder) {
+	if v, changed := f.DecMapUintBoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, canChange bool,
 	d *Decoder) (_ map[uint]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = uint(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]interface{})
-		v, changed := fastpathTV.DecMapUint8IntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]interface{})
+		if v, changed := fastpathTV.DecMapUint8IntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]interface{})
-		fastpathTV.DecMapUint8IntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), false, d)
 }
-func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8IntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, d *Decoder) {
+	if v, changed := f.DecMapUint8IntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, canChange bool,
 	d *Decoder) (_ map[uint8]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[uint8]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uint8
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]string)
-		v, changed := fastpathTV.DecMapUint8StringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]string)
+		if v, changed := fastpathTV.DecMapUint8StringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]string)
-		fastpathTV.DecMapUint8StringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8StringV(rv2i(rv).(map[uint8]string), false, d)
 }
-func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8StringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, d *Decoder) {
+	if v, changed := f.DecMapUint8StringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, canChange bool,
 	d *Decoder) (_ map[uint8]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[uint8]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]uint)
-		v, changed := fastpathTV.DecMapUint8UintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint)
+		if v, changed := fastpathTV.DecMapUint8UintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]uint)
-		fastpathTV.DecMapUint8UintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8UintV(rv2i(rv).(map[uint8]uint), false, d)
 }
-func (f fastpathT) DecMapUint8UintX(vp *map[uint8]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8UintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8UintX(vp *map[uint8]uint, d *Decoder) {
+	if v, changed := f.DecMapUint8UintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, canChange bool,
 	d *Decoder) (_ map[uint8]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint8]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]uint8)
-		v, changed := fastpathTV.DecMapUint8Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint8)
+		if v, changed := fastpathTV.DecMapUint8Uint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]uint8)
-		fastpathTV.DecMapUint8Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), false, d)
 }
-func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Uint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, d *Decoder) {
+	if v, changed := f.DecMapUint8Uint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, canChange bool,
 	d *Decoder) (_ map[uint8]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
 		v = make(map[uint8]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]uint16)
-		v, changed := fastpathTV.DecMapUint8Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint16)
+		if v, changed := fastpathTV.DecMapUint8Uint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]uint16)
-		fastpathTV.DecMapUint8Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), false, d)
 }
-func (f fastpathT) DecMapUint8Uint16X(vp *map[uint8]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Uint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8Uint16X(vp *map[uint8]uint16, d *Decoder) {
+	if v, changed := f.DecMapUint8Uint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, canChange bool,
 	d *Decoder) (_ map[uint8]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[uint8]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]uint32)
-		v, changed := fastpathTV.DecMapUint8Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint32)
+		if v, changed := fastpathTV.DecMapUint8Uint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]uint32)
-		fastpathTV.DecMapUint8Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), false, d)
 }
-func (f fastpathT) DecMapUint8Uint32X(vp *map[uint8]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Uint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8Uint32X(vp *map[uint8]uint32, d *Decoder) {
+	if v, changed := f.DecMapUint8Uint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, canChange bool,
 	d *Decoder) (_ map[uint8]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[uint8]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]uint64)
-		v, changed := fastpathTV.DecMapUint8Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint64)
+		if v, changed := fastpathTV.DecMapUint8Uint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]uint64)
-		fastpathTV.DecMapUint8Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), false, d)
 }
-func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Uint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, d *Decoder) {
+	if v, changed := f.DecMapUint8Uint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, canChange bool,
 	d *Decoder) (_ map[uint8]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint8]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]uintptr)
-		v, changed := fastpathTV.DecMapUint8UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uintptr)
+		if v, changed := fastpathTV.DecMapUint8UintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]uintptr)
-		fastpathTV.DecMapUint8UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), false, d)
 }
-func (f fastpathT) DecMapUint8UintptrX(vp *map[uint8]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8UintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8UintptrX(vp *map[uint8]uintptr, d *Decoder) {
+	if v, changed := f.DecMapUint8UintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, canChange bool,
 	d *Decoder) (_ map[uint8]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint8]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]int)
-		v, changed := fastpathTV.DecMapUint8IntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int)
+		if v, changed := fastpathTV.DecMapUint8IntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]int)
-		fastpathTV.DecMapUint8IntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8IntV(rv2i(rv).(map[uint8]int), false, d)
 }
-func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8IntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, d *Decoder) {
+	if v, changed := f.DecMapUint8IntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, canChange bool,
 	d *Decoder) (_ map[uint8]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint8]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]int8)
-		v, changed := fastpathTV.DecMapUint8Int8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int8)
+		if v, changed := fastpathTV.DecMapUint8Int8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]int8)
-		fastpathTV.DecMapUint8Int8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8Int8V(rv2i(rv).(map[uint8]int8), false, d)
 }
-func (f fastpathT) DecMapUint8Int8X(vp *map[uint8]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Int8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8Int8X(vp *map[uint8]int8, d *Decoder) {
+	if v, changed := f.DecMapUint8Int8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, canChange bool,
 	d *Decoder) (_ map[uint8]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
 		v = make(map[uint8]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]int16)
-		v, changed := fastpathTV.DecMapUint8Int16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int16)
+		if v, changed := fastpathTV.DecMapUint8Int16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]int16)
-		fastpathTV.DecMapUint8Int16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8Int16V(rv2i(rv).(map[uint8]int16), false, d)
 }
-func (f fastpathT) DecMapUint8Int16X(vp *map[uint8]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Int16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8Int16X(vp *map[uint8]int16, d *Decoder) {
+	if v, changed := f.DecMapUint8Int16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, canChange bool,
 	d *Decoder) (_ map[uint8]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[uint8]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]int32)
-		v, changed := fastpathTV.DecMapUint8Int32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int32)
+		if v, changed := fastpathTV.DecMapUint8Int32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]int32)
-		fastpathTV.DecMapUint8Int32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8Int32V(rv2i(rv).(map[uint8]int32), false, d)
 }
-func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Int32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, d *Decoder) {
+	if v, changed := f.DecMapUint8Int32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, canChange bool,
 	d *Decoder) (_ map[uint8]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[uint8]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]int64)
-		v, changed := fastpathTV.DecMapUint8Int64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int64)
+		if v, changed := fastpathTV.DecMapUint8Int64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]int64)
-		fastpathTV.DecMapUint8Int64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8Int64V(rv2i(rv).(map[uint8]int64), false, d)
 }
-func (f fastpathT) DecMapUint8Int64X(vp *map[uint8]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Int64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8Int64X(vp *map[uint8]int64, d *Decoder) {
+	if v, changed := f.DecMapUint8Int64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, canChange bool,
 	d *Decoder) (_ map[uint8]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint8]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]float32)
-		v, changed := fastpathTV.DecMapUint8Float32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]float32)
+		if v, changed := fastpathTV.DecMapUint8Float32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]float32)
-		fastpathTV.DecMapUint8Float32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8Float32V(rv2i(rv).(map[uint8]float32), false, d)
 }
-func (f fastpathT) DecMapUint8Float32X(vp *map[uint8]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Float32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8Float32X(vp *map[uint8]float32, d *Decoder) {
+	if v, changed := f.DecMapUint8Float32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, canChange bool,
 	d *Decoder) (_ map[uint8]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[uint8]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]float64)
-		v, changed := fastpathTV.DecMapUint8Float64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]float64)
+		if v, changed := fastpathTV.DecMapUint8Float64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]float64)
-		fastpathTV.DecMapUint8Float64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8Float64V(rv2i(rv).(map[uint8]float64), false, d)
 }
-func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Float64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, d *Decoder) {
+	if v, changed := f.DecMapUint8Float64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, canChange bool,
 	d *Decoder) (_ map[uint8]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint8]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint8]bool)
-		v, changed := fastpathTV.DecMapUint8BoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]bool)
+		if v, changed := fastpathTV.DecMapUint8BoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint8]bool)
-		fastpathTV.DecMapUint8BoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint8BoolV(rv2i(rv).(map[uint8]bool), false, d)
 }
-func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8BoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, d *Decoder) {
+	if v, changed := f.DecMapUint8BoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, canChange bool,
 	d *Decoder) (_ map[uint8]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
 		v = make(map[uint8]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint8
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint8(dd.DecodeUint(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = uint8(dd.DecodeUint(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]interface{})
-		v, changed := fastpathTV.DecMapUint16IntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]interface{})
+		if v, changed := fastpathTV.DecMapUint16IntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]interface{})
-		fastpathTV.DecMapUint16IntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), false, d)
 }
-func (f fastpathT) DecMapUint16IntfX(vp *map[uint16]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16IntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16IntfX(vp *map[uint16]interface{}, d *Decoder) {
+	if v, changed := f.DecMapUint16IntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, canChange bool,
 	d *Decoder) (_ map[uint16]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
 		v = make(map[uint16]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uint16
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]string)
-		v, changed := fastpathTV.DecMapUint16StringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]string)
+		if v, changed := fastpathTV.DecMapUint16StringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]string)
-		fastpathTV.DecMapUint16StringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16StringV(rv2i(rv).(map[uint16]string), false, d)
 }
-func (f fastpathT) DecMapUint16StringX(vp *map[uint16]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16StringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16StringX(vp *map[uint16]string, d *Decoder) {
+	if v, changed := f.DecMapUint16StringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, canChange bool,
 	d *Decoder) (_ map[uint16]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
 		v = make(map[uint16]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]uint)
-		v, changed := fastpathTV.DecMapUint16UintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint)
+		if v, changed := fastpathTV.DecMapUint16UintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]uint)
-		fastpathTV.DecMapUint16UintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16UintV(rv2i(rv).(map[uint16]uint), false, d)
 }
-func (f fastpathT) DecMapUint16UintX(vp *map[uint16]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16UintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16UintX(vp *map[uint16]uint, d *Decoder) {
+	if v, changed := f.DecMapUint16UintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, canChange bool,
 	d *Decoder) (_ map[uint16]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uint16]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]uint8)
-		v, changed := fastpathTV.DecMapUint16Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint8)
+		if v, changed := fastpathTV.DecMapUint16Uint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]uint8)
-		fastpathTV.DecMapUint16Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), false, d)
 }
-func (f fastpathT) DecMapUint16Uint8X(vp *map[uint16]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Uint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16Uint8X(vp *map[uint16]uint8, d *Decoder) {
+	if v, changed := f.DecMapUint16Uint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, canChange bool,
 	d *Decoder) (_ map[uint16]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[uint16]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]uint16)
-		v, changed := fastpathTV.DecMapUint16Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint16)
+		if v, changed := fastpathTV.DecMapUint16Uint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]uint16)
-		fastpathTV.DecMapUint16Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), false, d)
 }
-func (f fastpathT) DecMapUint16Uint16X(vp *map[uint16]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Uint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16Uint16X(vp *map[uint16]uint16, d *Decoder) {
+	if v, changed := f.DecMapUint16Uint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, canChange bool,
 	d *Decoder) (_ map[uint16]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 4)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
 		v = make(map[uint16]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]uint32)
-		v, changed := fastpathTV.DecMapUint16Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint32)
+		if v, changed := fastpathTV.DecMapUint16Uint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]uint32)
-		fastpathTV.DecMapUint16Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), false, d)
 }
-func (f fastpathT) DecMapUint16Uint32X(vp *map[uint16]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Uint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16Uint32X(vp *map[uint16]uint32, d *Decoder) {
+	if v, changed := f.DecMapUint16Uint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, canChange bool,
 	d *Decoder) (_ map[uint16]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[uint16]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]uint64)
-		v, changed := fastpathTV.DecMapUint16Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint64)
+		if v, changed := fastpathTV.DecMapUint16Uint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]uint64)
-		fastpathTV.DecMapUint16Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), false, d)
 }
-func (f fastpathT) DecMapUint16Uint64X(vp *map[uint16]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Uint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16Uint64X(vp *map[uint16]uint64, d *Decoder) {
+	if v, changed := f.DecMapUint16Uint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, canChange bool,
 	d *Decoder) (_ map[uint16]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uint16]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]uintptr)
-		v, changed := fastpathTV.DecMapUint16UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uintptr)
+		if v, changed := fastpathTV.DecMapUint16UintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]uintptr)
-		fastpathTV.DecMapUint16UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), false, d)
 }
-func (f fastpathT) DecMapUint16UintptrX(vp *map[uint16]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16UintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16UintptrX(vp *map[uint16]uintptr, d *Decoder) {
+	if v, changed := f.DecMapUint16UintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, canChange bool,
 	d *Decoder) (_ map[uint16]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uint16]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]int)
-		v, changed := fastpathTV.DecMapUint16IntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int)
+		if v, changed := fastpathTV.DecMapUint16IntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]int)
-		fastpathTV.DecMapUint16IntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16IntV(rv2i(rv).(map[uint16]int), false, d)
 }
-func (f fastpathT) DecMapUint16IntX(vp *map[uint16]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16IntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16IntX(vp *map[uint16]int, d *Decoder) {
+	if v, changed := f.DecMapUint16IntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, canChange bool,
 	d *Decoder) (_ map[uint16]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uint16]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]int8)
-		v, changed := fastpathTV.DecMapUint16Int8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int8)
+		if v, changed := fastpathTV.DecMapUint16Int8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]int8)
-		fastpathTV.DecMapUint16Int8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16Int8V(rv2i(rv).(map[uint16]int8), false, d)
 }
-func (f fastpathT) DecMapUint16Int8X(vp *map[uint16]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Int8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16Int8X(vp *map[uint16]int8, d *Decoder) {
+	if v, changed := f.DecMapUint16Int8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, canChange bool,
 	d *Decoder) (_ map[uint16]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[uint16]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]int16)
-		v, changed := fastpathTV.DecMapUint16Int16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int16)
+		if v, changed := fastpathTV.DecMapUint16Int16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]int16)
-		fastpathTV.DecMapUint16Int16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16Int16V(rv2i(rv).(map[uint16]int16), false, d)
 }
-func (f fastpathT) DecMapUint16Int16X(vp *map[uint16]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Int16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16Int16X(vp *map[uint16]int16, d *Decoder) {
+	if v, changed := f.DecMapUint16Int16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, canChange bool,
 	d *Decoder) (_ map[uint16]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 4)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
 		v = make(map[uint16]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]int32)
-		v, changed := fastpathTV.DecMapUint16Int32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int32)
+		if v, changed := fastpathTV.DecMapUint16Int32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]int32)
-		fastpathTV.DecMapUint16Int32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16Int32V(rv2i(rv).(map[uint16]int32), false, d)
 }
-func (f fastpathT) DecMapUint16Int32X(vp *map[uint16]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Int32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16Int32X(vp *map[uint16]int32, d *Decoder) {
+	if v, changed := f.DecMapUint16Int32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, canChange bool,
 	d *Decoder) (_ map[uint16]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[uint16]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]int64)
-		v, changed := fastpathTV.DecMapUint16Int64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int64)
+		if v, changed := fastpathTV.DecMapUint16Int64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]int64)
-		fastpathTV.DecMapUint16Int64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16Int64V(rv2i(rv).(map[uint16]int64), false, d)
 }
-func (f fastpathT) DecMapUint16Int64X(vp *map[uint16]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Int64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16Int64X(vp *map[uint16]int64, d *Decoder) {
+	if v, changed := f.DecMapUint16Int64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, canChange bool,
 	d *Decoder) (_ map[uint16]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uint16]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]float32)
-		v, changed := fastpathTV.DecMapUint16Float32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]float32)
+		if v, changed := fastpathTV.DecMapUint16Float32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]float32)
-		fastpathTV.DecMapUint16Float32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16Float32V(rv2i(rv).(map[uint16]float32), false, d)
 }
-func (f fastpathT) DecMapUint16Float32X(vp *map[uint16]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Float32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16Float32X(vp *map[uint16]float32, d *Decoder) {
+	if v, changed := f.DecMapUint16Float32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, canChange bool,
 	d *Decoder) (_ map[uint16]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[uint16]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]float64)
-		v, changed := fastpathTV.DecMapUint16Float64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]float64)
+		if v, changed := fastpathTV.DecMapUint16Float64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]float64)
-		fastpathTV.DecMapUint16Float64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16Float64V(rv2i(rv).(map[uint16]float64), false, d)
 }
-func (f fastpathT) DecMapUint16Float64X(vp *map[uint16]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Float64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16Float64X(vp *map[uint16]float64, d *Decoder) {
+	if v, changed := f.DecMapUint16Float64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, canChange bool,
 	d *Decoder) (_ map[uint16]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uint16]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint16]bool)
-		v, changed := fastpathTV.DecMapUint16BoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]bool)
+		if v, changed := fastpathTV.DecMapUint16BoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint16]bool)
-		fastpathTV.DecMapUint16BoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint16BoolV(rv2i(rv).(map[uint16]bool), false, d)
 }
-func (f fastpathT) DecMapUint16BoolX(vp *map[uint16]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16BoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint16BoolX(vp *map[uint16]bool, d *Decoder) {
+	if v, changed := f.DecMapUint16BoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, canChange bool,
 	d *Decoder) (_ map[uint16]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[uint16]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint16
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint16(dd.DecodeUint(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = uint16(dd.DecodeUint(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]interface{})
-		v, changed := fastpathTV.DecMapUint32IntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]interface{})
+		if v, changed := fastpathTV.DecMapUint32IntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]interface{})
-		fastpathTV.DecMapUint32IntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), false, d)
 }
-func (f fastpathT) DecMapUint32IntfX(vp *map[uint32]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32IntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32IntfX(vp *map[uint32]interface{}, d *Decoder) {
+	if v, changed := f.DecMapUint32IntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, canChange bool,
 	d *Decoder) (_ map[uint32]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[uint32]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uint32
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]string)
-		v, changed := fastpathTV.DecMapUint32StringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]string)
+		if v, changed := fastpathTV.DecMapUint32StringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]string)
-		fastpathTV.DecMapUint32StringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32StringV(rv2i(rv).(map[uint32]string), false, d)
 }
-func (f fastpathT) DecMapUint32StringX(vp *map[uint32]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32StringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32StringX(vp *map[uint32]string, d *Decoder) {
+	if v, changed := f.DecMapUint32StringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, canChange bool,
 	d *Decoder) (_ map[uint32]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[uint32]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]uint)
-		v, changed := fastpathTV.DecMapUint32UintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint)
+		if v, changed := fastpathTV.DecMapUint32UintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]uint)
-		fastpathTV.DecMapUint32UintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32UintV(rv2i(rv).(map[uint32]uint), false, d)
 }
-func (f fastpathT) DecMapUint32UintX(vp *map[uint32]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32UintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32UintX(vp *map[uint32]uint, d *Decoder) {
+	if v, changed := f.DecMapUint32UintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, canChange bool,
 	d *Decoder) (_ map[uint32]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint32]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]uint8)
-		v, changed := fastpathTV.DecMapUint32Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint8)
+		if v, changed := fastpathTV.DecMapUint32Uint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]uint8)
-		fastpathTV.DecMapUint32Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), false, d)
 }
-func (f fastpathT) DecMapUint32Uint8X(vp *map[uint32]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Uint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32Uint8X(vp *map[uint32]uint8, d *Decoder) {
+	if v, changed := f.DecMapUint32Uint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, canChange bool,
 	d *Decoder) (_ map[uint32]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[uint32]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]uint16)
-		v, changed := fastpathTV.DecMapUint32Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint16)
+		if v, changed := fastpathTV.DecMapUint32Uint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]uint16)
-		fastpathTV.DecMapUint32Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), false, d)
 }
-func (f fastpathT) DecMapUint32Uint16X(vp *map[uint32]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Uint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32Uint16X(vp *map[uint32]uint16, d *Decoder) {
+	if v, changed := f.DecMapUint32Uint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, canChange bool,
 	d *Decoder) (_ map[uint32]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[uint32]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]uint32)
-		v, changed := fastpathTV.DecMapUint32Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint32)
+		if v, changed := fastpathTV.DecMapUint32Uint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]uint32)
-		fastpathTV.DecMapUint32Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), false, d)
 }
-func (f fastpathT) DecMapUint32Uint32X(vp *map[uint32]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Uint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32Uint32X(vp *map[uint32]uint32, d *Decoder) {
+	if v, changed := f.DecMapUint32Uint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, canChange bool,
 	d *Decoder) (_ map[uint32]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
 		v = make(map[uint32]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]uint64)
-		v, changed := fastpathTV.DecMapUint32Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint64)
+		if v, changed := fastpathTV.DecMapUint32Uint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]uint64)
-		fastpathTV.DecMapUint32Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), false, d)
 }
-func (f fastpathT) DecMapUint32Uint64X(vp *map[uint32]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Uint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32Uint64X(vp *map[uint32]uint64, d *Decoder) {
+	if v, changed := f.DecMapUint32Uint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, canChange bool,
 	d *Decoder) (_ map[uint32]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint32]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]uintptr)
-		v, changed := fastpathTV.DecMapUint32UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uintptr)
+		if v, changed := fastpathTV.DecMapUint32UintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]uintptr)
-		fastpathTV.DecMapUint32UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), false, d)
 }
-func (f fastpathT) DecMapUint32UintptrX(vp *map[uint32]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32UintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32UintptrX(vp *map[uint32]uintptr, d *Decoder) {
+	if v, changed := f.DecMapUint32UintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, canChange bool,
 	d *Decoder) (_ map[uint32]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint32]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]int)
-		v, changed := fastpathTV.DecMapUint32IntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int)
+		if v, changed := fastpathTV.DecMapUint32IntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]int)
-		fastpathTV.DecMapUint32IntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32IntV(rv2i(rv).(map[uint32]int), false, d)
 }
-func (f fastpathT) DecMapUint32IntX(vp *map[uint32]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32IntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32IntX(vp *map[uint32]int, d *Decoder) {
+	if v, changed := f.DecMapUint32IntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, canChange bool,
 	d *Decoder) (_ map[uint32]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint32]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]int8)
-		v, changed := fastpathTV.DecMapUint32Int8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int8)
+		if v, changed := fastpathTV.DecMapUint32Int8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]int8)
-		fastpathTV.DecMapUint32Int8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32Int8V(rv2i(rv).(map[uint32]int8), false, d)
 }
-func (f fastpathT) DecMapUint32Int8X(vp *map[uint32]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Int8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32Int8X(vp *map[uint32]int8, d *Decoder) {
+	if v, changed := f.DecMapUint32Int8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, canChange bool,
 	d *Decoder) (_ map[uint32]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[uint32]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]int16)
-		v, changed := fastpathTV.DecMapUint32Int16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int16)
+		if v, changed := fastpathTV.DecMapUint32Int16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]int16)
-		fastpathTV.DecMapUint32Int16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32Int16V(rv2i(rv).(map[uint32]int16), false, d)
 }
-func (f fastpathT) DecMapUint32Int16X(vp *map[uint32]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Int16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32Int16X(vp *map[uint32]int16, d *Decoder) {
+	if v, changed := f.DecMapUint32Int16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, canChange bool,
 	d *Decoder) (_ map[uint32]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[uint32]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]int32)
-		v, changed := fastpathTV.DecMapUint32Int32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int32)
+		if v, changed := fastpathTV.DecMapUint32Int32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]int32)
-		fastpathTV.DecMapUint32Int32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32Int32V(rv2i(rv).(map[uint32]int32), false, d)
 }
-func (f fastpathT) DecMapUint32Int32X(vp *map[uint32]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Int32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32Int32X(vp *map[uint32]int32, d *Decoder) {
+	if v, changed := f.DecMapUint32Int32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, canChange bool,
 	d *Decoder) (_ map[uint32]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
 		v = make(map[uint32]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]int64)
-		v, changed := fastpathTV.DecMapUint32Int64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int64)
+		if v, changed := fastpathTV.DecMapUint32Int64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]int64)
-		fastpathTV.DecMapUint32Int64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32Int64V(rv2i(rv).(map[uint32]int64), false, d)
 }
-func (f fastpathT) DecMapUint32Int64X(vp *map[uint32]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Int64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32Int64X(vp *map[uint32]int64, d *Decoder) {
+	if v, changed := f.DecMapUint32Int64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, canChange bool,
 	d *Decoder) (_ map[uint32]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint32]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]float32)
-		v, changed := fastpathTV.DecMapUint32Float32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]float32)
+		if v, changed := fastpathTV.DecMapUint32Float32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]float32)
-		fastpathTV.DecMapUint32Float32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32Float32V(rv2i(rv).(map[uint32]float32), false, d)
 }
-func (f fastpathT) DecMapUint32Float32X(vp *map[uint32]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Float32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32Float32X(vp *map[uint32]float32, d *Decoder) {
+	if v, changed := f.DecMapUint32Float32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, canChange bool,
 	d *Decoder) (_ map[uint32]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
 		v = make(map[uint32]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]float64)
-		v, changed := fastpathTV.DecMapUint32Float64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]float64)
+		if v, changed := fastpathTV.DecMapUint32Float64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]float64)
-		fastpathTV.DecMapUint32Float64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32Float64V(rv2i(rv).(map[uint32]float64), false, d)
 }
-func (f fastpathT) DecMapUint32Float64X(vp *map[uint32]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Float64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32Float64X(vp *map[uint32]float64, d *Decoder) {
+	if v, changed := f.DecMapUint32Float64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, canChange bool,
 	d *Decoder) (_ map[uint32]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint32]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint32]bool)
-		v, changed := fastpathTV.DecMapUint32BoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]bool)
+		if v, changed := fastpathTV.DecMapUint32BoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint32]bool)
-		fastpathTV.DecMapUint32BoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint32BoolV(rv2i(rv).(map[uint32]bool), false, d)
 }
-func (f fastpathT) DecMapUint32BoolX(vp *map[uint32]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32BoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint32BoolX(vp *map[uint32]bool, d *Decoder) {
+	if v, changed := f.DecMapUint32BoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, canChange bool,
 	d *Decoder) (_ map[uint32]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[uint32]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint32
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uint32(dd.DecodeUint(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = uint32(dd.DecodeUint(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]interface{})
-		v, changed := fastpathTV.DecMapUint64IntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]interface{})
+		if v, changed := fastpathTV.DecMapUint64IntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]interface{})
-		fastpathTV.DecMapUint64IntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), false, d)
 }
-func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64IntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, d *Decoder) {
+	if v, changed := f.DecMapUint64IntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, canChange bool,
 	d *Decoder) (_ map[uint64]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[uint64]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uint64
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]string)
-		v, changed := fastpathTV.DecMapUint64StringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]string)
+		if v, changed := fastpathTV.DecMapUint64StringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]string)
-		fastpathTV.DecMapUint64StringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64StringV(rv2i(rv).(map[uint64]string), false, d)
 }
-func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64StringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, d *Decoder) {
+	if v, changed := f.DecMapUint64StringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, canChange bool,
 	d *Decoder) (_ map[uint64]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[uint64]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]uint)
-		v, changed := fastpathTV.DecMapUint64UintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint)
+		if v, changed := fastpathTV.DecMapUint64UintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]uint)
-		fastpathTV.DecMapUint64UintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64UintV(rv2i(rv).(map[uint64]uint), false, d)
 }
-func (f fastpathT) DecMapUint64UintX(vp *map[uint64]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64UintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64UintX(vp *map[uint64]uint, d *Decoder) {
+	if v, changed := f.DecMapUint64UintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, canChange bool,
 	d *Decoder) (_ map[uint64]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint64]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]uint8)
-		v, changed := fastpathTV.DecMapUint64Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint8)
+		if v, changed := fastpathTV.DecMapUint64Uint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]uint8)
-		fastpathTV.DecMapUint64Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), false, d)
 }
-func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Uint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, d *Decoder) {
+	if v, changed := f.DecMapUint64Uint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, canChange bool,
 	d *Decoder) (_ map[uint64]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint64]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]uint16)
-		v, changed := fastpathTV.DecMapUint64Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint16)
+		if v, changed := fastpathTV.DecMapUint64Uint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]uint16)
-		fastpathTV.DecMapUint64Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), false, d)
 }
-func (f fastpathT) DecMapUint64Uint16X(vp *map[uint64]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Uint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64Uint16X(vp *map[uint64]uint16, d *Decoder) {
+	if v, changed := f.DecMapUint64Uint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, canChange bool,
 	d *Decoder) (_ map[uint64]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uint64]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]uint32)
-		v, changed := fastpathTV.DecMapUint64Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint32)
+		if v, changed := fastpathTV.DecMapUint64Uint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]uint32)
-		fastpathTV.DecMapUint64Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), false, d)
 }
-func (f fastpathT) DecMapUint64Uint32X(vp *map[uint64]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Uint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64Uint32X(vp *map[uint64]uint32, d *Decoder) {
+	if v, changed := f.DecMapUint64Uint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, canChange bool,
 	d *Decoder) (_ map[uint64]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint64]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]uint64)
-		v, changed := fastpathTV.DecMapUint64Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint64)
+		if v, changed := fastpathTV.DecMapUint64Uint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]uint64)
-		fastpathTV.DecMapUint64Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), false, d)
 }
-func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Uint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, d *Decoder) {
+	if v, changed := f.DecMapUint64Uint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, canChange bool,
 	d *Decoder) (_ map[uint64]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint64]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]uintptr)
-		v, changed := fastpathTV.DecMapUint64UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uintptr)
+		if v, changed := fastpathTV.DecMapUint64UintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]uintptr)
-		fastpathTV.DecMapUint64UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), false, d)
 }
-func (f fastpathT) DecMapUint64UintptrX(vp *map[uint64]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64UintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64UintptrX(vp *map[uint64]uintptr, d *Decoder) {
+	if v, changed := f.DecMapUint64UintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, canChange bool,
 	d *Decoder) (_ map[uint64]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint64]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]int)
-		v, changed := fastpathTV.DecMapUint64IntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int)
+		if v, changed := fastpathTV.DecMapUint64IntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]int)
-		fastpathTV.DecMapUint64IntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64IntV(rv2i(rv).(map[uint64]int), false, d)
 }
-func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64IntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, d *Decoder) {
+	if v, changed := f.DecMapUint64IntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, canChange bool,
 	d *Decoder) (_ map[uint64]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint64]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]int8)
-		v, changed := fastpathTV.DecMapUint64Int8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int8)
+		if v, changed := fastpathTV.DecMapUint64Int8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]int8)
-		fastpathTV.DecMapUint64Int8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64Int8V(rv2i(rv).(map[uint64]int8), false, d)
 }
-func (f fastpathT) DecMapUint64Int8X(vp *map[uint64]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Int8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64Int8X(vp *map[uint64]int8, d *Decoder) {
+	if v, changed := f.DecMapUint64Int8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, canChange bool,
 	d *Decoder) (_ map[uint64]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint64]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]int16)
-		v, changed := fastpathTV.DecMapUint64Int16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int16)
+		if v, changed := fastpathTV.DecMapUint64Int16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]int16)
-		fastpathTV.DecMapUint64Int16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64Int16V(rv2i(rv).(map[uint64]int16), false, d)
 }
-func (f fastpathT) DecMapUint64Int16X(vp *map[uint64]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Int16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64Int16X(vp *map[uint64]int16, d *Decoder) {
+	if v, changed := f.DecMapUint64Int16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, canChange bool,
 	d *Decoder) (_ map[uint64]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uint64]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]int32)
-		v, changed := fastpathTV.DecMapUint64Int32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int32)
+		if v, changed := fastpathTV.DecMapUint64Int32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]int32)
-		fastpathTV.DecMapUint64Int32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64Int32V(rv2i(rv).(map[uint64]int32), false, d)
 }
-func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Int32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, d *Decoder) {
+	if v, changed := f.DecMapUint64Int32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, canChange bool,
 	d *Decoder) (_ map[uint64]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint64]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]int64)
-		v, changed := fastpathTV.DecMapUint64Int64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int64)
+		if v, changed := fastpathTV.DecMapUint64Int64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]int64)
-		fastpathTV.DecMapUint64Int64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64Int64V(rv2i(rv).(map[uint64]int64), false, d)
 }
-func (f fastpathT) DecMapUint64Int64X(vp *map[uint64]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Int64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64Int64X(vp *map[uint64]int64, d *Decoder) {
+	if v, changed := f.DecMapUint64Int64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, canChange bool,
 	d *Decoder) (_ map[uint64]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint64]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]float32)
-		v, changed := fastpathTV.DecMapUint64Float32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]float32)
+		if v, changed := fastpathTV.DecMapUint64Float32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]float32)
-		fastpathTV.DecMapUint64Float32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64Float32V(rv2i(rv).(map[uint64]float32), false, d)
 }
-func (f fastpathT) DecMapUint64Float32X(vp *map[uint64]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Float32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64Float32X(vp *map[uint64]float32, d *Decoder) {
+	if v, changed := f.DecMapUint64Float32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, canChange bool,
 	d *Decoder) (_ map[uint64]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uint64]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]float64)
-		v, changed := fastpathTV.DecMapUint64Float64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]float64)
+		if v, changed := fastpathTV.DecMapUint64Float64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]float64)
-		fastpathTV.DecMapUint64Float64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64Float64V(rv2i(rv).(map[uint64]float64), false, d)
 }
-func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Float64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, d *Decoder) {
+	if v, changed := f.DecMapUint64Float64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, canChange bool,
 	d *Decoder) (_ map[uint64]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uint64]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uint64]bool)
-		v, changed := fastpathTV.DecMapUint64BoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]bool)
+		if v, changed := fastpathTV.DecMapUint64BoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uint64]bool)
-		fastpathTV.DecMapUint64BoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUint64BoolV(rv2i(rv).(map[uint64]bool), false, d)
 }
-func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64BoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, d *Decoder) {
+	if v, changed := f.DecMapUint64BoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, canChange bool,
 	d *Decoder) (_ map[uint64]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uint64]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uint64
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeUint(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeUint(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]interface{})
-		v, changed := fastpathTV.DecMapUintptrIntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]interface{})
+		if v, changed := fastpathTV.DecMapUintptrIntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]interface{})
-		fastpathTV.DecMapUintptrIntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), false, d)
 }
-func (f fastpathT) DecMapUintptrIntfX(vp *map[uintptr]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrIntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrIntfX(vp *map[uintptr]interface{}, d *Decoder) {
+	if v, changed := f.DecMapUintptrIntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, canChange bool,
 	d *Decoder) (_ map[uintptr]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[uintptr]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uintptr
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]string)
-		v, changed := fastpathTV.DecMapUintptrStringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]string)
+		if v, changed := fastpathTV.DecMapUintptrStringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]string)
-		fastpathTV.DecMapUintptrStringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrStringV(rv2i(rv).(map[uintptr]string), false, d)
 }
-func (f fastpathT) DecMapUintptrStringX(vp *map[uintptr]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrStringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrStringX(vp *map[uintptr]string, d *Decoder) {
+	if v, changed := f.DecMapUintptrStringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, canChange bool,
 	d *Decoder) (_ map[uintptr]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[uintptr]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]uint)
-		v, changed := fastpathTV.DecMapUintptrUintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint)
+		if v, changed := fastpathTV.DecMapUintptrUintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]uint)
-		fastpathTV.DecMapUintptrUintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrUintV(rv2i(rv).(map[uintptr]uint), false, d)
 }
-func (f fastpathT) DecMapUintptrUintX(vp *map[uintptr]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrUintX(vp *map[uintptr]uint, d *Decoder) {
+	if v, changed := f.DecMapUintptrUintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, canChange bool,
 	d *Decoder) (_ map[uintptr]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uintptr]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]uint8)
-		v, changed := fastpathTV.DecMapUintptrUint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint8)
+		if v, changed := fastpathTV.DecMapUintptrUint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]uint8)
-		fastpathTV.DecMapUintptrUint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), false, d)
 }
-func (f fastpathT) DecMapUintptrUint8X(vp *map[uintptr]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrUint8X(vp *map[uintptr]uint8, d *Decoder) {
+	if v, changed := f.DecMapUintptrUint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, canChange bool,
 	d *Decoder) (_ map[uintptr]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uintptr]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]uint16)
-		v, changed := fastpathTV.DecMapUintptrUint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint16)
+		if v, changed := fastpathTV.DecMapUintptrUint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]uint16)
-		fastpathTV.DecMapUintptrUint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), false, d)
 }
-func (f fastpathT) DecMapUintptrUint16X(vp *map[uintptr]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrUint16X(vp *map[uintptr]uint16, d *Decoder) {
+	if v, changed := f.DecMapUintptrUint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, canChange bool,
 	d *Decoder) (_ map[uintptr]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uintptr]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]uint32)
-		v, changed := fastpathTV.DecMapUintptrUint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint32)
+		if v, changed := fastpathTV.DecMapUintptrUint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]uint32)
-		fastpathTV.DecMapUintptrUint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), false, d)
 }
-func (f fastpathT) DecMapUintptrUint32X(vp *map[uintptr]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrUint32X(vp *map[uintptr]uint32, d *Decoder) {
+	if v, changed := f.DecMapUintptrUint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, canChange bool,
 	d *Decoder) (_ map[uintptr]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uintptr]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]uint64)
-		v, changed := fastpathTV.DecMapUintptrUint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint64)
+		if v, changed := fastpathTV.DecMapUintptrUint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]uint64)
-		fastpathTV.DecMapUintptrUint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), false, d)
 }
-func (f fastpathT) DecMapUintptrUint64X(vp *map[uintptr]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrUint64X(vp *map[uintptr]uint64, d *Decoder) {
+	if v, changed := f.DecMapUintptrUint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, canChange bool,
 	d *Decoder) (_ map[uintptr]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uintptr]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]uintptr)
-		v, changed := fastpathTV.DecMapUintptrUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uintptr)
+		if v, changed := fastpathTV.DecMapUintptrUintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]uintptr)
-		fastpathTV.DecMapUintptrUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), false, d)
 }
-func (f fastpathT) DecMapUintptrUintptrX(vp *map[uintptr]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrUintptrX(vp *map[uintptr]uintptr, d *Decoder) {
+	if v, changed := f.DecMapUintptrUintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, canChange bool,
 	d *Decoder) (_ map[uintptr]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uintptr]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]int)
-		v, changed := fastpathTV.DecMapUintptrIntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int)
+		if v, changed := fastpathTV.DecMapUintptrIntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]int)
-		fastpathTV.DecMapUintptrIntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrIntV(rv2i(rv).(map[uintptr]int), false, d)
 }
-func (f fastpathT) DecMapUintptrIntX(vp *map[uintptr]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrIntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrIntX(vp *map[uintptr]int, d *Decoder) {
+	if v, changed := f.DecMapUintptrIntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, canChange bool,
 	d *Decoder) (_ map[uintptr]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uintptr]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]int8)
-		v, changed := fastpathTV.DecMapUintptrInt8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int8)
+		if v, changed := fastpathTV.DecMapUintptrInt8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]int8)
-		fastpathTV.DecMapUintptrInt8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), false, d)
 }
-func (f fastpathT) DecMapUintptrInt8X(vp *map[uintptr]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrInt8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrInt8X(vp *map[uintptr]int8, d *Decoder) {
+	if v, changed := f.DecMapUintptrInt8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, canChange bool,
 	d *Decoder) (_ map[uintptr]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uintptr]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]int16)
-		v, changed := fastpathTV.DecMapUintptrInt16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int16)
+		if v, changed := fastpathTV.DecMapUintptrInt16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]int16)
-		fastpathTV.DecMapUintptrInt16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), false, d)
 }
-func (f fastpathT) DecMapUintptrInt16X(vp *map[uintptr]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrInt16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrInt16X(vp *map[uintptr]int16, d *Decoder) {
+	if v, changed := f.DecMapUintptrInt16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, canChange bool,
 	d *Decoder) (_ map[uintptr]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[uintptr]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]int32)
-		v, changed := fastpathTV.DecMapUintptrInt32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int32)
+		if v, changed := fastpathTV.DecMapUintptrInt32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]int32)
-		fastpathTV.DecMapUintptrInt32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), false, d)
 }
-func (f fastpathT) DecMapUintptrInt32X(vp *map[uintptr]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrInt32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrInt32X(vp *map[uintptr]int32, d *Decoder) {
+	if v, changed := f.DecMapUintptrInt32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, canChange bool,
 	d *Decoder) (_ map[uintptr]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uintptr]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]int64)
-		v, changed := fastpathTV.DecMapUintptrInt64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int64)
+		if v, changed := fastpathTV.DecMapUintptrInt64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]int64)
-		fastpathTV.DecMapUintptrInt64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), false, d)
 }
-func (f fastpathT) DecMapUintptrInt64X(vp *map[uintptr]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrInt64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrInt64X(vp *map[uintptr]int64, d *Decoder) {
+	if v, changed := f.DecMapUintptrInt64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, canChange bool,
 	d *Decoder) (_ map[uintptr]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uintptr]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]float32)
-		v, changed := fastpathTV.DecMapUintptrFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]float32)
+		if v, changed := fastpathTV.DecMapUintptrFloat32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]float32)
-		fastpathTV.DecMapUintptrFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), false, d)
 }
-func (f fastpathT) DecMapUintptrFloat32X(vp *map[uintptr]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrFloat32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrFloat32X(vp *map[uintptr]float32, d *Decoder) {
+	if v, changed := f.DecMapUintptrFloat32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, canChange bool,
 	d *Decoder) (_ map[uintptr]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[uintptr]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]float64)
-		v, changed := fastpathTV.DecMapUintptrFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]float64)
+		if v, changed := fastpathTV.DecMapUintptrFloat64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]float64)
-		fastpathTV.DecMapUintptrFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), false, d)
 }
-func (f fastpathT) DecMapUintptrFloat64X(vp *map[uintptr]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrFloat64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrFloat64X(vp *map[uintptr]float64, d *Decoder) {
+	if v, changed := f.DecMapUintptrFloat64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, canChange bool,
 	d *Decoder) (_ map[uintptr]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[uintptr]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[uintptr]bool)
-		v, changed := fastpathTV.DecMapUintptrBoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]bool)
+		if v, changed := fastpathTV.DecMapUintptrBoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[uintptr]bool)
-		fastpathTV.DecMapUintptrBoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), false, d)
 }
-func (f fastpathT) DecMapUintptrBoolX(vp *map[uintptr]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrBoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapUintptrBoolX(vp *map[uintptr]bool, d *Decoder) {
+	if v, changed := f.DecMapUintptrBoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, canChange bool,
 	d *Decoder) (_ map[uintptr]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[uintptr]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk uintptr
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = uintptr(dd.DecodeUint(uintBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = uintptr(dd.DecodeUint(uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]interface{})
-		v, changed := fastpathTV.DecMapIntIntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]interface{})
+		if v, changed := fastpathTV.DecMapIntIntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]interface{})
-		fastpathTV.DecMapIntIntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntIntfV(rv2i(rv).(map[int]interface{}), false, d)
 }
-func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntIntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, d *Decoder) {
+	if v, changed := f.DecMapIntIntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, canChange bool,
 	d *Decoder) (_ map[int]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[int]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk int
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]string)
-		v, changed := fastpathTV.DecMapIntStringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]string)
+		if v, changed := fastpathTV.DecMapIntStringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]string)
-		fastpathTV.DecMapIntStringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntStringV(rv2i(rv).(map[int]string), false, d)
 }
-func (f fastpathT) DecMapIntStringX(vp *map[int]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntStringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntStringX(vp *map[int]string, d *Decoder) {
+	if v, changed := f.DecMapIntStringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntStringV(v map[int]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntStringV(v map[int]string, canChange bool,
 	d *Decoder) (_ map[int]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[int]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]uint)
-		v, changed := fastpathTV.DecMapIntUintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint)
+		if v, changed := fastpathTV.DecMapIntUintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]uint)
-		fastpathTV.DecMapIntUintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntUintV(rv2i(rv).(map[int]uint), false, d)
 }
-func (f fastpathT) DecMapIntUintX(vp *map[int]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntUintX(vp *map[int]uint, d *Decoder) {
+	if v, changed := f.DecMapIntUintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUintV(v map[int]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUintV(v map[int]uint, canChange bool,
 	d *Decoder) (_ map[int]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]uint8)
-		v, changed := fastpathTV.DecMapIntUint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint8)
+		if v, changed := fastpathTV.DecMapIntUint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]uint8)
-		fastpathTV.DecMapIntUint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntUint8V(rv2i(rv).(map[int]uint8), false, d)
 }
-func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, d *Decoder) {
+	if v, changed := f.DecMapIntUint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, canChange bool,
 	d *Decoder) (_ map[int]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]uint16)
-		v, changed := fastpathTV.DecMapIntUint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint16)
+		if v, changed := fastpathTV.DecMapIntUint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]uint16)
-		fastpathTV.DecMapIntUint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntUint16V(rv2i(rv).(map[int]uint16), false, d)
 }
-func (f fastpathT) DecMapIntUint16X(vp *map[int]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntUint16X(vp *map[int]uint16, d *Decoder) {
+	if v, changed := f.DecMapIntUint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, canChange bool,
 	d *Decoder) (_ map[int]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[int]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]uint32)
-		v, changed := fastpathTV.DecMapIntUint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint32)
+		if v, changed := fastpathTV.DecMapIntUint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]uint32)
-		fastpathTV.DecMapIntUint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntUint32V(rv2i(rv).(map[int]uint32), false, d)
 }
-func (f fastpathT) DecMapIntUint32X(vp *map[int]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntUint32X(vp *map[int]uint32, d *Decoder) {
+	if v, changed := f.DecMapIntUint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, canChange bool,
 	d *Decoder) (_ map[int]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]uint64)
-		v, changed := fastpathTV.DecMapIntUint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint64)
+		if v, changed := fastpathTV.DecMapIntUint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]uint64)
-		fastpathTV.DecMapIntUint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntUint64V(rv2i(rv).(map[int]uint64), false, d)
 }
-func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, d *Decoder) {
+	if v, changed := f.DecMapIntUint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, canChange bool,
 	d *Decoder) (_ map[int]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]uintptr)
-		v, changed := fastpathTV.DecMapIntUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uintptr)
+		if v, changed := fastpathTV.DecMapIntUintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]uintptr)
-		fastpathTV.DecMapIntUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntUintptrV(rv2i(rv).(map[int]uintptr), false, d)
 }
-func (f fastpathT) DecMapIntUintptrX(vp *map[int]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntUintptrX(vp *map[int]uintptr, d *Decoder) {
+	if v, changed := f.DecMapIntUintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, canChange bool,
 	d *Decoder) (_ map[int]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]int)
-		v, changed := fastpathTV.DecMapIntIntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int)
+		if v, changed := fastpathTV.DecMapIntIntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]int)
-		fastpathTV.DecMapIntIntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntIntV(rv2i(rv).(map[int]int), false, d)
 }
-func (f fastpathT) DecMapIntIntX(vp *map[int]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntIntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntIntX(vp *map[int]int, d *Decoder) {
+	if v, changed := f.DecMapIntIntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntIntV(v map[int]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntIntV(v map[int]int, canChange bool,
 	d *Decoder) (_ map[int]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]int8)
-		v, changed := fastpathTV.DecMapIntInt8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int8)
+		if v, changed := fastpathTV.DecMapIntInt8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]int8)
-		fastpathTV.DecMapIntInt8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntInt8V(rv2i(rv).(map[int]int8), false, d)
 }
-func (f fastpathT) DecMapIntInt8X(vp *map[int]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntInt8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntInt8X(vp *map[int]int8, d *Decoder) {
+	if v, changed := f.DecMapIntInt8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntInt8V(v map[int]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntInt8V(v map[int]int8, canChange bool,
 	d *Decoder) (_ map[int]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]int16)
-		v, changed := fastpathTV.DecMapIntInt16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int16)
+		if v, changed := fastpathTV.DecMapIntInt16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]int16)
-		fastpathTV.DecMapIntInt16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntInt16V(rv2i(rv).(map[int]int16), false, d)
 }
-func (f fastpathT) DecMapIntInt16X(vp *map[int]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntInt16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntInt16X(vp *map[int]int16, d *Decoder) {
+	if v, changed := f.DecMapIntInt16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntInt16V(v map[int]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntInt16V(v map[int]int16, canChange bool,
 	d *Decoder) (_ map[int]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[int]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]int32)
-		v, changed := fastpathTV.DecMapIntInt32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int32)
+		if v, changed := fastpathTV.DecMapIntInt32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]int32)
-		fastpathTV.DecMapIntInt32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntInt32V(rv2i(rv).(map[int]int32), false, d)
 }
-func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntInt32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, d *Decoder) {
+	if v, changed := f.DecMapIntInt32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntInt32V(v map[int]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntInt32V(v map[int]int32, canChange bool,
 	d *Decoder) (_ map[int]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]int64)
-		v, changed := fastpathTV.DecMapIntInt64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int64)
+		if v, changed := fastpathTV.DecMapIntInt64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]int64)
-		fastpathTV.DecMapIntInt64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntInt64V(rv2i(rv).(map[int]int64), false, d)
 }
-func (f fastpathT) DecMapIntInt64X(vp *map[int]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntInt64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntInt64X(vp *map[int]int64, d *Decoder) {
+	if v, changed := f.DecMapIntInt64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntInt64V(v map[int]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntInt64V(v map[int]int64, canChange bool,
 	d *Decoder) (_ map[int]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]float32)
-		v, changed := fastpathTV.DecMapIntFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]float32)
+		if v, changed := fastpathTV.DecMapIntFloat32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]float32)
-		fastpathTV.DecMapIntFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntFloat32V(rv2i(rv).(map[int]float32), false, d)
 }
-func (f fastpathT) DecMapIntFloat32X(vp *map[int]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntFloat32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntFloat32X(vp *map[int]float32, d *Decoder) {
+	if v, changed := f.DecMapIntFloat32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, canChange bool,
 	d *Decoder) (_ map[int]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]float64)
-		v, changed := fastpathTV.DecMapIntFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]float64)
+		if v, changed := fastpathTV.DecMapIntFloat64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]float64)
-		fastpathTV.DecMapIntFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntFloat64V(rv2i(rv).(map[int]float64), false, d)
 }
-func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntFloat64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, d *Decoder) {
+	if v, changed := f.DecMapIntFloat64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, canChange bool,
 	d *Decoder) (_ map[int]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int]bool)
-		v, changed := fastpathTV.DecMapIntBoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]bool)
+		if v, changed := fastpathTV.DecMapIntBoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int]bool)
-		fastpathTV.DecMapIntBoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapIntBoolV(rv2i(rv).(map[int]bool), false, d)
 }
-func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntBoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, d *Decoder) {
+	if v, changed := f.DecMapIntBoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntBoolV(v map[int]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntBoolV(v map[int]bool, canChange bool,
 	d *Decoder) (_ map[int]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int(dd.DecodeInt(intBitsize))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = int(dd.DecodeInt(intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]interface{})
-		v, changed := fastpathTV.DecMapInt8IntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]interface{})
+		if v, changed := fastpathTV.DecMapInt8IntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]interface{})
-		fastpathTV.DecMapInt8IntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8IntfV(rv2i(rv).(map[int8]interface{}), false, d)
 }
-func (f fastpathT) DecMapInt8IntfX(vp *map[int8]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8IntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8IntfX(vp *map[int8]interface{}, d *Decoder) {
+	if v, changed := f.DecMapInt8IntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, canChange bool,
 	d *Decoder) (_ map[int8]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[int8]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk int8
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]string)
-		v, changed := fastpathTV.DecMapInt8StringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]string)
+		if v, changed := fastpathTV.DecMapInt8StringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]string)
-		fastpathTV.DecMapInt8StringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8StringV(rv2i(rv).(map[int8]string), false, d)
 }
-func (f fastpathT) DecMapInt8StringX(vp *map[int8]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8StringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8StringX(vp *map[int8]string, d *Decoder) {
+	if v, changed := f.DecMapInt8StringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8StringV(v map[int8]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8StringV(v map[int8]string, canChange bool,
 	d *Decoder) (_ map[int8]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[int8]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]uint)
-		v, changed := fastpathTV.DecMapInt8UintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint)
+		if v, changed := fastpathTV.DecMapInt8UintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]uint)
-		fastpathTV.DecMapInt8UintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8UintV(rv2i(rv).(map[int8]uint), false, d)
 }
-func (f fastpathT) DecMapInt8UintX(vp *map[int8]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8UintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8UintX(vp *map[int8]uint, d *Decoder) {
+	if v, changed := f.DecMapInt8UintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, canChange bool,
 	d *Decoder) (_ map[int8]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int8]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]uint8)
-		v, changed := fastpathTV.DecMapInt8Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint8)
+		if v, changed := fastpathTV.DecMapInt8Uint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]uint8)
-		fastpathTV.DecMapInt8Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8Uint8V(rv2i(rv).(map[int8]uint8), false, d)
 }
-func (f fastpathT) DecMapInt8Uint8X(vp *map[int8]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Uint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8Uint8X(vp *map[int8]uint8, d *Decoder) {
+	if v, changed := f.DecMapInt8Uint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, canChange bool,
 	d *Decoder) (_ map[int8]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
 		v = make(map[int8]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]uint16)
-		v, changed := fastpathTV.DecMapInt8Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint16)
+		if v, changed := fastpathTV.DecMapInt8Uint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]uint16)
-		fastpathTV.DecMapInt8Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8Uint16V(rv2i(rv).(map[int8]uint16), false, d)
 }
-func (f fastpathT) DecMapInt8Uint16X(vp *map[int8]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Uint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8Uint16X(vp *map[int8]uint16, d *Decoder) {
+	if v, changed := f.DecMapInt8Uint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, canChange bool,
 	d *Decoder) (_ map[int8]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[int8]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]uint32)
-		v, changed := fastpathTV.DecMapInt8Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint32)
+		if v, changed := fastpathTV.DecMapInt8Uint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]uint32)
-		fastpathTV.DecMapInt8Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8Uint32V(rv2i(rv).(map[int8]uint32), false, d)
 }
-func (f fastpathT) DecMapInt8Uint32X(vp *map[int8]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Uint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8Uint32X(vp *map[int8]uint32, d *Decoder) {
+	if v, changed := f.DecMapInt8Uint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, canChange bool,
 	d *Decoder) (_ map[int8]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[int8]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]uint64)
-		v, changed := fastpathTV.DecMapInt8Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint64)
+		if v, changed := fastpathTV.DecMapInt8Uint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]uint64)
-		fastpathTV.DecMapInt8Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8Uint64V(rv2i(rv).(map[int8]uint64), false, d)
 }
-func (f fastpathT) DecMapInt8Uint64X(vp *map[int8]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Uint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8Uint64X(vp *map[int8]uint64, d *Decoder) {
+	if v, changed := f.DecMapInt8Uint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, canChange bool,
 	d *Decoder) (_ map[int8]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int8]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]uintptr)
-		v, changed := fastpathTV.DecMapInt8UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uintptr)
+		if v, changed := fastpathTV.DecMapInt8UintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]uintptr)
-		fastpathTV.DecMapInt8UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), false, d)
 }
-func (f fastpathT) DecMapInt8UintptrX(vp *map[int8]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8UintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8UintptrX(vp *map[int8]uintptr, d *Decoder) {
+	if v, changed := f.DecMapInt8UintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, canChange bool,
 	d *Decoder) (_ map[int8]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int8]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]int)
-		v, changed := fastpathTV.DecMapInt8IntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int)
+		if v, changed := fastpathTV.DecMapInt8IntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]int)
-		fastpathTV.DecMapInt8IntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8IntV(rv2i(rv).(map[int8]int), false, d)
 }
-func (f fastpathT) DecMapInt8IntX(vp *map[int8]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8IntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8IntX(vp *map[int8]int, d *Decoder) {
+	if v, changed := f.DecMapInt8IntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8IntV(v map[int8]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8IntV(v map[int8]int, canChange bool,
 	d *Decoder) (_ map[int8]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int8]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]int8)
-		v, changed := fastpathTV.DecMapInt8Int8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int8)
+		if v, changed := fastpathTV.DecMapInt8Int8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]int8)
-		fastpathTV.DecMapInt8Int8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8Int8V(rv2i(rv).(map[int8]int8), false, d)
 }
-func (f fastpathT) DecMapInt8Int8X(vp *map[int8]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Int8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8Int8X(vp *map[int8]int8, d *Decoder) {
+	if v, changed := f.DecMapInt8Int8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, canChange bool,
 	d *Decoder) (_ map[int8]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
 		v = make(map[int8]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]int16)
-		v, changed := fastpathTV.DecMapInt8Int16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int16)
+		if v, changed := fastpathTV.DecMapInt8Int16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]int16)
-		fastpathTV.DecMapInt8Int16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8Int16V(rv2i(rv).(map[int8]int16), false, d)
 }
-func (f fastpathT) DecMapInt8Int16X(vp *map[int8]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Int16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8Int16X(vp *map[int8]int16, d *Decoder) {
+	if v, changed := f.DecMapInt8Int16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, canChange bool,
 	d *Decoder) (_ map[int8]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[int8]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]int32)
-		v, changed := fastpathTV.DecMapInt8Int32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int32)
+		if v, changed := fastpathTV.DecMapInt8Int32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]int32)
-		fastpathTV.DecMapInt8Int32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8Int32V(rv2i(rv).(map[int8]int32), false, d)
 }
-func (f fastpathT) DecMapInt8Int32X(vp *map[int8]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Int32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8Int32X(vp *map[int8]int32, d *Decoder) {
+	if v, changed := f.DecMapInt8Int32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, canChange bool,
 	d *Decoder) (_ map[int8]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[int8]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]int64)
-		v, changed := fastpathTV.DecMapInt8Int64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int64)
+		if v, changed := fastpathTV.DecMapInt8Int64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]int64)
-		fastpathTV.DecMapInt8Int64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8Int64V(rv2i(rv).(map[int8]int64), false, d)
 }
-func (f fastpathT) DecMapInt8Int64X(vp *map[int8]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Int64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8Int64X(vp *map[int8]int64, d *Decoder) {
+	if v, changed := f.DecMapInt8Int64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, canChange bool,
 	d *Decoder) (_ map[int8]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int8]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]float32)
-		v, changed := fastpathTV.DecMapInt8Float32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]float32)
+		if v, changed := fastpathTV.DecMapInt8Float32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]float32)
-		fastpathTV.DecMapInt8Float32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8Float32V(rv2i(rv).(map[int8]float32), false, d)
 }
-func (f fastpathT) DecMapInt8Float32X(vp *map[int8]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Float32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8Float32X(vp *map[int8]float32, d *Decoder) {
+	if v, changed := f.DecMapInt8Float32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, canChange bool,
 	d *Decoder) (_ map[int8]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[int8]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]float64)
-		v, changed := fastpathTV.DecMapInt8Float64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]float64)
+		if v, changed := fastpathTV.DecMapInt8Float64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]float64)
-		fastpathTV.DecMapInt8Float64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8Float64V(rv2i(rv).(map[int8]float64), false, d)
 }
-func (f fastpathT) DecMapInt8Float64X(vp *map[int8]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Float64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8Float64X(vp *map[int8]float64, d *Decoder) {
+	if v, changed := f.DecMapInt8Float64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, canChange bool,
 	d *Decoder) (_ map[int8]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int8]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int8]bool)
-		v, changed := fastpathTV.DecMapInt8BoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]bool)
+		if v, changed := fastpathTV.DecMapInt8BoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int8]bool)
-		fastpathTV.DecMapInt8BoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt8BoolV(rv2i(rv).(map[int8]bool), false, d)
 }
-func (f fastpathT) DecMapInt8BoolX(vp *map[int8]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8BoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt8BoolX(vp *map[int8]bool, d *Decoder) {
+	if v, changed := f.DecMapInt8BoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, canChange bool,
 	d *Decoder) (_ map[int8]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
 		v = make(map[int8]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int8
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int8(dd.DecodeInt(8))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = int8(dd.DecodeInt(8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]interface{})
-		v, changed := fastpathTV.DecMapInt16IntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]interface{})
+		if v, changed := fastpathTV.DecMapInt16IntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]interface{})
-		fastpathTV.DecMapInt16IntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16IntfV(rv2i(rv).(map[int16]interface{}), false, d)
 }
-func (f fastpathT) DecMapInt16IntfX(vp *map[int16]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16IntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16IntfX(vp *map[int16]interface{}, d *Decoder) {
+	if v, changed := f.DecMapInt16IntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, canChange bool,
 	d *Decoder) (_ map[int16]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
 		v = make(map[int16]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk int16
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]string)
-		v, changed := fastpathTV.DecMapInt16StringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]string)
+		if v, changed := fastpathTV.DecMapInt16StringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]string)
-		fastpathTV.DecMapInt16StringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16StringV(rv2i(rv).(map[int16]string), false, d)
 }
-func (f fastpathT) DecMapInt16StringX(vp *map[int16]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16StringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16StringX(vp *map[int16]string, d *Decoder) {
+	if v, changed := f.DecMapInt16StringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16StringV(v map[int16]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16StringV(v map[int16]string, canChange bool,
 	d *Decoder) (_ map[int16]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 18)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
 		v = make(map[int16]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]uint)
-		v, changed := fastpathTV.DecMapInt16UintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint)
+		if v, changed := fastpathTV.DecMapInt16UintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]uint)
-		fastpathTV.DecMapInt16UintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16UintV(rv2i(rv).(map[int16]uint), false, d)
 }
-func (f fastpathT) DecMapInt16UintX(vp *map[int16]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16UintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16UintX(vp *map[int16]uint, d *Decoder) {
+	if v, changed := f.DecMapInt16UintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, canChange bool,
 	d *Decoder) (_ map[int16]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[int16]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]uint8)
-		v, changed := fastpathTV.DecMapInt16Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint8)
+		if v, changed := fastpathTV.DecMapInt16Uint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]uint8)
-		fastpathTV.DecMapInt16Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16Uint8V(rv2i(rv).(map[int16]uint8), false, d)
 }
-func (f fastpathT) DecMapInt16Uint8X(vp *map[int16]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Uint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16Uint8X(vp *map[int16]uint8, d *Decoder) {
+	if v, changed := f.DecMapInt16Uint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, canChange bool,
 	d *Decoder) (_ map[int16]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[int16]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]uint16)
-		v, changed := fastpathTV.DecMapInt16Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint16)
+		if v, changed := fastpathTV.DecMapInt16Uint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]uint16)
-		fastpathTV.DecMapInt16Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16Uint16V(rv2i(rv).(map[int16]uint16), false, d)
 }
-func (f fastpathT) DecMapInt16Uint16X(vp *map[int16]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Uint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16Uint16X(vp *map[int16]uint16, d *Decoder) {
+	if v, changed := f.DecMapInt16Uint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, canChange bool,
 	d *Decoder) (_ map[int16]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 4)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
 		v = make(map[int16]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]uint32)
-		v, changed := fastpathTV.DecMapInt16Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint32)
+		if v, changed := fastpathTV.DecMapInt16Uint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]uint32)
-		fastpathTV.DecMapInt16Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16Uint32V(rv2i(rv).(map[int16]uint32), false, d)
 }
-func (f fastpathT) DecMapInt16Uint32X(vp *map[int16]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Uint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16Uint32X(vp *map[int16]uint32, d *Decoder) {
+	if v, changed := f.DecMapInt16Uint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, canChange bool,
 	d *Decoder) (_ map[int16]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[int16]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]uint64)
-		v, changed := fastpathTV.DecMapInt16Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint64)
+		if v, changed := fastpathTV.DecMapInt16Uint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]uint64)
-		fastpathTV.DecMapInt16Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16Uint64V(rv2i(rv).(map[int16]uint64), false, d)
 }
-func (f fastpathT) DecMapInt16Uint64X(vp *map[int16]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Uint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16Uint64X(vp *map[int16]uint64, d *Decoder) {
+	if v, changed := f.DecMapInt16Uint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, canChange bool,
 	d *Decoder) (_ map[int16]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[int16]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]uintptr)
-		v, changed := fastpathTV.DecMapInt16UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uintptr)
+		if v, changed := fastpathTV.DecMapInt16UintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]uintptr)
-		fastpathTV.DecMapInt16UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), false, d)
 }
-func (f fastpathT) DecMapInt16UintptrX(vp *map[int16]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16UintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16UintptrX(vp *map[int16]uintptr, d *Decoder) {
+	if v, changed := f.DecMapInt16UintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, canChange bool,
 	d *Decoder) (_ map[int16]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[int16]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]int)
-		v, changed := fastpathTV.DecMapInt16IntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int)
+		if v, changed := fastpathTV.DecMapInt16IntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]int)
-		fastpathTV.DecMapInt16IntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16IntV(rv2i(rv).(map[int16]int), false, d)
 }
-func (f fastpathT) DecMapInt16IntX(vp *map[int16]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16IntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16IntX(vp *map[int16]int, d *Decoder) {
+	if v, changed := f.DecMapInt16IntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16IntV(v map[int16]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16IntV(v map[int16]int, canChange bool,
 	d *Decoder) (_ map[int16]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[int16]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]int8)
-		v, changed := fastpathTV.DecMapInt16Int8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int8)
+		if v, changed := fastpathTV.DecMapInt16Int8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]int8)
-		fastpathTV.DecMapInt16Int8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16Int8V(rv2i(rv).(map[int16]int8), false, d)
 }
-func (f fastpathT) DecMapInt16Int8X(vp *map[int16]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Int8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16Int8X(vp *map[int16]int8, d *Decoder) {
+	if v, changed := f.DecMapInt16Int8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, canChange bool,
 	d *Decoder) (_ map[int16]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[int16]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]int16)
-		v, changed := fastpathTV.DecMapInt16Int16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int16)
+		if v, changed := fastpathTV.DecMapInt16Int16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]int16)
-		fastpathTV.DecMapInt16Int16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16Int16V(rv2i(rv).(map[int16]int16), false, d)
 }
-func (f fastpathT) DecMapInt16Int16X(vp *map[int16]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Int16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16Int16X(vp *map[int16]int16, d *Decoder) {
+	if v, changed := f.DecMapInt16Int16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, canChange bool,
 	d *Decoder) (_ map[int16]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 4)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
 		v = make(map[int16]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]int32)
-		v, changed := fastpathTV.DecMapInt16Int32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int32)
+		if v, changed := fastpathTV.DecMapInt16Int32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]int32)
-		fastpathTV.DecMapInt16Int32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16Int32V(rv2i(rv).(map[int16]int32), false, d)
 }
-func (f fastpathT) DecMapInt16Int32X(vp *map[int16]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Int32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16Int32X(vp *map[int16]int32, d *Decoder) {
+	if v, changed := f.DecMapInt16Int32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, canChange bool,
 	d *Decoder) (_ map[int16]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[int16]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]int64)
-		v, changed := fastpathTV.DecMapInt16Int64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int64)
+		if v, changed := fastpathTV.DecMapInt16Int64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]int64)
-		fastpathTV.DecMapInt16Int64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16Int64V(rv2i(rv).(map[int16]int64), false, d)
 }
-func (f fastpathT) DecMapInt16Int64X(vp *map[int16]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Int64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16Int64X(vp *map[int16]int64, d *Decoder) {
+	if v, changed := f.DecMapInt16Int64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, canChange bool,
 	d *Decoder) (_ map[int16]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[int16]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]float32)
-		v, changed := fastpathTV.DecMapInt16Float32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]float32)
+		if v, changed := fastpathTV.DecMapInt16Float32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]float32)
-		fastpathTV.DecMapInt16Float32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16Float32V(rv2i(rv).(map[int16]float32), false, d)
 }
-func (f fastpathT) DecMapInt16Float32X(vp *map[int16]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Float32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16Float32X(vp *map[int16]float32, d *Decoder) {
+	if v, changed := f.DecMapInt16Float32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, canChange bool,
 	d *Decoder) (_ map[int16]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[int16]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]float64)
-		v, changed := fastpathTV.DecMapInt16Float64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]float64)
+		if v, changed := fastpathTV.DecMapInt16Float64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]float64)
-		fastpathTV.DecMapInt16Float64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16Float64V(rv2i(rv).(map[int16]float64), false, d)
 }
-func (f fastpathT) DecMapInt16Float64X(vp *map[int16]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Float64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16Float64X(vp *map[int16]float64, d *Decoder) {
+	if v, changed := f.DecMapInt16Float64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, canChange bool,
 	d *Decoder) (_ map[int16]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[int16]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int16]bool)
-		v, changed := fastpathTV.DecMapInt16BoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]bool)
+		if v, changed := fastpathTV.DecMapInt16BoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int16]bool)
-		fastpathTV.DecMapInt16BoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt16BoolV(rv2i(rv).(map[int16]bool), false, d)
 }
-func (f fastpathT) DecMapInt16BoolX(vp *map[int16]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16BoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt16BoolX(vp *map[int16]bool, d *Decoder) {
+	if v, changed := f.DecMapInt16BoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, canChange bool,
 	d *Decoder) (_ map[int16]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[int16]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int16
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int16(dd.DecodeInt(16))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = int16(dd.DecodeInt(16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]interface{})
-		v, changed := fastpathTV.DecMapInt32IntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]interface{})
+		if v, changed := fastpathTV.DecMapInt32IntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]interface{})
-		fastpathTV.DecMapInt32IntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32IntfV(rv2i(rv).(map[int32]interface{}), false, d)
 }
-func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32IntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, d *Decoder) {
+	if v, changed := f.DecMapInt32IntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, canChange bool,
 	d *Decoder) (_ map[int32]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[int32]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk int32
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]string)
-		v, changed := fastpathTV.DecMapInt32StringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]string)
+		if v, changed := fastpathTV.DecMapInt32StringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]string)
-		fastpathTV.DecMapInt32StringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32StringV(rv2i(rv).(map[int32]string), false, d)
 }
-func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32StringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, d *Decoder) {
+	if v, changed := f.DecMapInt32StringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32StringV(v map[int32]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32StringV(v map[int32]string, canChange bool,
 	d *Decoder) (_ map[int32]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 20)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
 		v = make(map[int32]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]uint)
-		v, changed := fastpathTV.DecMapInt32UintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint)
+		if v, changed := fastpathTV.DecMapInt32UintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]uint)
-		fastpathTV.DecMapInt32UintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32UintV(rv2i(rv).(map[int32]uint), false, d)
 }
-func (f fastpathT) DecMapInt32UintX(vp *map[int32]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32UintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32UintX(vp *map[int32]uint, d *Decoder) {
+	if v, changed := f.DecMapInt32UintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, canChange bool,
 	d *Decoder) (_ map[int32]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int32]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]uint8)
-		v, changed := fastpathTV.DecMapInt32Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint8)
+		if v, changed := fastpathTV.DecMapInt32Uint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]uint8)
-		fastpathTV.DecMapInt32Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32Uint8V(rv2i(rv).(map[int32]uint8), false, d)
 }
-func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Uint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, d *Decoder) {
+	if v, changed := f.DecMapInt32Uint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, canChange bool,
 	d *Decoder) (_ map[int32]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[int32]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]uint16)
-		v, changed := fastpathTV.DecMapInt32Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint16)
+		if v, changed := fastpathTV.DecMapInt32Uint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]uint16)
-		fastpathTV.DecMapInt32Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32Uint16V(rv2i(rv).(map[int32]uint16), false, d)
 }
-func (f fastpathT) DecMapInt32Uint16X(vp *map[int32]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Uint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32Uint16X(vp *map[int32]uint16, d *Decoder) {
+	if v, changed := f.DecMapInt32Uint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, canChange bool,
 	d *Decoder) (_ map[int32]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[int32]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]uint32)
-		v, changed := fastpathTV.DecMapInt32Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint32)
+		if v, changed := fastpathTV.DecMapInt32Uint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]uint32)
-		fastpathTV.DecMapInt32Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32Uint32V(rv2i(rv).(map[int32]uint32), false, d)
 }
-func (f fastpathT) DecMapInt32Uint32X(vp *map[int32]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Uint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32Uint32X(vp *map[int32]uint32, d *Decoder) {
+	if v, changed := f.DecMapInt32Uint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, canChange bool,
 	d *Decoder) (_ map[int32]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
 		v = make(map[int32]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]uint64)
-		v, changed := fastpathTV.DecMapInt32Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint64)
+		if v, changed := fastpathTV.DecMapInt32Uint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]uint64)
-		fastpathTV.DecMapInt32Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32Uint64V(rv2i(rv).(map[int32]uint64), false, d)
 }
-func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Uint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, d *Decoder) {
+	if v, changed := f.DecMapInt32Uint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, canChange bool,
 	d *Decoder) (_ map[int32]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int32]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]uintptr)
-		v, changed := fastpathTV.DecMapInt32UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uintptr)
+		if v, changed := fastpathTV.DecMapInt32UintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]uintptr)
-		fastpathTV.DecMapInt32UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), false, d)
 }
-func (f fastpathT) DecMapInt32UintptrX(vp *map[int32]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32UintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32UintptrX(vp *map[int32]uintptr, d *Decoder) {
+	if v, changed := f.DecMapInt32UintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, canChange bool,
 	d *Decoder) (_ map[int32]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int32]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]int)
-		v, changed := fastpathTV.DecMapInt32IntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int)
+		if v, changed := fastpathTV.DecMapInt32IntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]int)
-		fastpathTV.DecMapInt32IntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32IntV(rv2i(rv).(map[int32]int), false, d)
 }
-func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32IntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, d *Decoder) {
+	if v, changed := f.DecMapInt32IntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32IntV(v map[int32]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32IntV(v map[int32]int, canChange bool,
 	d *Decoder) (_ map[int32]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int32]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]int8)
-		v, changed := fastpathTV.DecMapInt32Int8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int8)
+		if v, changed := fastpathTV.DecMapInt32Int8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]int8)
-		fastpathTV.DecMapInt32Int8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32Int8V(rv2i(rv).(map[int32]int8), false, d)
 }
-func (f fastpathT) DecMapInt32Int8X(vp *map[int32]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Int8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32Int8X(vp *map[int32]int8, d *Decoder) {
+	if v, changed := f.DecMapInt32Int8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, canChange bool,
 	d *Decoder) (_ map[int32]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[int32]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]int16)
-		v, changed := fastpathTV.DecMapInt32Int16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int16)
+		if v, changed := fastpathTV.DecMapInt32Int16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]int16)
-		fastpathTV.DecMapInt32Int16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32Int16V(rv2i(rv).(map[int32]int16), false, d)
 }
-func (f fastpathT) DecMapInt32Int16X(vp *map[int32]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Int16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32Int16X(vp *map[int32]int16, d *Decoder) {
+	if v, changed := f.DecMapInt32Int16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, canChange bool,
 	d *Decoder) (_ map[int32]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 6)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
 		v = make(map[int32]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]int32)
-		v, changed := fastpathTV.DecMapInt32Int32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int32)
+		if v, changed := fastpathTV.DecMapInt32Int32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]int32)
-		fastpathTV.DecMapInt32Int32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32Int32V(rv2i(rv).(map[int32]int32), false, d)
 }
-func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Int32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, d *Decoder) {
+	if v, changed := f.DecMapInt32Int32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, canChange bool,
 	d *Decoder) (_ map[int32]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
 		v = make(map[int32]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]int64)
-		v, changed := fastpathTV.DecMapInt32Int64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int64)
+		if v, changed := fastpathTV.DecMapInt32Int64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]int64)
-		fastpathTV.DecMapInt32Int64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32Int64V(rv2i(rv).(map[int32]int64), false, d)
 }
-func (f fastpathT) DecMapInt32Int64X(vp *map[int32]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Int64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32Int64X(vp *map[int32]int64, d *Decoder) {
+	if v, changed := f.DecMapInt32Int64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, canChange bool,
 	d *Decoder) (_ map[int32]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int32]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]float32)
-		v, changed := fastpathTV.DecMapInt32Float32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]float32)
+		if v, changed := fastpathTV.DecMapInt32Float32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]float32)
-		fastpathTV.DecMapInt32Float32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32Float32V(rv2i(rv).(map[int32]float32), false, d)
 }
-func (f fastpathT) DecMapInt32Float32X(vp *map[int32]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Float32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32Float32X(vp *map[int32]float32, d *Decoder) {
+	if v, changed := f.DecMapInt32Float32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, canChange bool,
 	d *Decoder) (_ map[int32]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 8)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
 		v = make(map[int32]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]float64)
-		v, changed := fastpathTV.DecMapInt32Float64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]float64)
+		if v, changed := fastpathTV.DecMapInt32Float64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]float64)
-		fastpathTV.DecMapInt32Float64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32Float64V(rv2i(rv).(map[int32]float64), false, d)
 }
-func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Float64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, d *Decoder) {
+	if v, changed := f.DecMapInt32Float64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, canChange bool,
 	d *Decoder) (_ map[int32]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int32]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int32]bool)
-		v, changed := fastpathTV.DecMapInt32BoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]bool)
+		if v, changed := fastpathTV.DecMapInt32BoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int32]bool)
-		fastpathTV.DecMapInt32BoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt32BoolV(rv2i(rv).(map[int32]bool), false, d)
 }
-func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32BoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, d *Decoder) {
+	if v, changed := f.DecMapInt32BoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, canChange bool,
 	d *Decoder) (_ map[int32]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[int32]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int32
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = int32(dd.DecodeInt(32))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = int32(dd.DecodeInt(32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]interface{})
-		v, changed := fastpathTV.DecMapInt64IntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]interface{})
+		if v, changed := fastpathTV.DecMapInt64IntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]interface{})
-		fastpathTV.DecMapInt64IntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64IntfV(rv2i(rv).(map[int64]interface{}), false, d)
 }
-func (f fastpathT) DecMapInt64IntfX(vp *map[int64]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64IntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64IntfX(vp *map[int64]interface{}, d *Decoder) {
+	if v, changed := f.DecMapInt64IntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, canChange bool,
 	d *Decoder) (_ map[int64]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[int64]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk int64
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]string)
-		v, changed := fastpathTV.DecMapInt64StringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]string)
+		if v, changed := fastpathTV.DecMapInt64StringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]string)
-		fastpathTV.DecMapInt64StringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64StringV(rv2i(rv).(map[int64]string), false, d)
 }
-func (f fastpathT) DecMapInt64StringX(vp *map[int64]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64StringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64StringX(vp *map[int64]string, d *Decoder) {
+	if v, changed := f.DecMapInt64StringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64StringV(v map[int64]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64StringV(v map[int64]string, canChange bool,
 	d *Decoder) (_ map[int64]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 24)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
 		v = make(map[int64]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]uint)
-		v, changed := fastpathTV.DecMapInt64UintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint)
+		if v, changed := fastpathTV.DecMapInt64UintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]uint)
-		fastpathTV.DecMapInt64UintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64UintV(rv2i(rv).(map[int64]uint), false, d)
 }
-func (f fastpathT) DecMapInt64UintX(vp *map[int64]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64UintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64UintX(vp *map[int64]uint, d *Decoder) {
+	if v, changed := f.DecMapInt64UintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, canChange bool,
 	d *Decoder) (_ map[int64]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int64]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]uint8)
-		v, changed := fastpathTV.DecMapInt64Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint8)
+		if v, changed := fastpathTV.DecMapInt64Uint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]uint8)
-		fastpathTV.DecMapInt64Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64Uint8V(rv2i(rv).(map[int64]uint8), false, d)
 }
-func (f fastpathT) DecMapInt64Uint8X(vp *map[int64]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Uint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64Uint8X(vp *map[int64]uint8, d *Decoder) {
+	if v, changed := f.DecMapInt64Uint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, canChange bool,
 	d *Decoder) (_ map[int64]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int64]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]uint16)
-		v, changed := fastpathTV.DecMapInt64Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint16)
+		if v, changed := fastpathTV.DecMapInt64Uint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]uint16)
-		fastpathTV.DecMapInt64Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64Uint16V(rv2i(rv).(map[int64]uint16), false, d)
 }
-func (f fastpathT) DecMapInt64Uint16X(vp *map[int64]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Uint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64Uint16X(vp *map[int64]uint16, d *Decoder) {
+	if v, changed := f.DecMapInt64Uint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, canChange bool,
 	d *Decoder) (_ map[int64]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[int64]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]uint32)
-		v, changed := fastpathTV.DecMapInt64Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint32)
+		if v, changed := fastpathTV.DecMapInt64Uint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]uint32)
-		fastpathTV.DecMapInt64Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64Uint32V(rv2i(rv).(map[int64]uint32), false, d)
 }
-func (f fastpathT) DecMapInt64Uint32X(vp *map[int64]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Uint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64Uint32X(vp *map[int64]uint32, d *Decoder) {
+	if v, changed := f.DecMapInt64Uint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, canChange bool,
 	d *Decoder) (_ map[int64]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int64]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]uint64)
-		v, changed := fastpathTV.DecMapInt64Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint64)
+		if v, changed := fastpathTV.DecMapInt64Uint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]uint64)
-		fastpathTV.DecMapInt64Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64Uint64V(rv2i(rv).(map[int64]uint64), false, d)
 }
-func (f fastpathT) DecMapInt64Uint64X(vp *map[int64]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Uint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64Uint64X(vp *map[int64]uint64, d *Decoder) {
+	if v, changed := f.DecMapInt64Uint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, canChange bool,
 	d *Decoder) (_ map[int64]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int64]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]uintptr)
-		v, changed := fastpathTV.DecMapInt64UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uintptr)
+		if v, changed := fastpathTV.DecMapInt64UintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]uintptr)
-		fastpathTV.DecMapInt64UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), false, d)
 }
-func (f fastpathT) DecMapInt64UintptrX(vp *map[int64]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64UintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64UintptrX(vp *map[int64]uintptr, d *Decoder) {
+	if v, changed := f.DecMapInt64UintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, canChange bool,
 	d *Decoder) (_ map[int64]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int64]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]int)
-		v, changed := fastpathTV.DecMapInt64IntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int)
+		if v, changed := fastpathTV.DecMapInt64IntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]int)
-		fastpathTV.DecMapInt64IntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64IntV(rv2i(rv).(map[int64]int), false, d)
 }
-func (f fastpathT) DecMapInt64IntX(vp *map[int64]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64IntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64IntX(vp *map[int64]int, d *Decoder) {
+	if v, changed := f.DecMapInt64IntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64IntV(v map[int64]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64IntV(v map[int64]int, canChange bool,
 	d *Decoder) (_ map[int64]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int64]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]int8)
-		v, changed := fastpathTV.DecMapInt64Int8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int8)
+		if v, changed := fastpathTV.DecMapInt64Int8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]int8)
-		fastpathTV.DecMapInt64Int8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64Int8V(rv2i(rv).(map[int64]int8), false, d)
 }
-func (f fastpathT) DecMapInt64Int8X(vp *map[int64]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Int8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64Int8X(vp *map[int64]int8, d *Decoder) {
+	if v, changed := f.DecMapInt64Int8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, canChange bool,
 	d *Decoder) (_ map[int64]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int64]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]int16)
-		v, changed := fastpathTV.DecMapInt64Int16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int16)
+		if v, changed := fastpathTV.DecMapInt64Int16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]int16)
-		fastpathTV.DecMapInt64Int16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64Int16V(rv2i(rv).(map[int64]int16), false, d)
 }
-func (f fastpathT) DecMapInt64Int16X(vp *map[int64]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Int16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64Int16X(vp *map[int64]int16, d *Decoder) {
+	if v, changed := f.DecMapInt64Int16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, canChange bool,
 	d *Decoder) (_ map[int64]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 10)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
 		v = make(map[int64]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]int32)
-		v, changed := fastpathTV.DecMapInt64Int32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int32)
+		if v, changed := fastpathTV.DecMapInt64Int32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]int32)
-		fastpathTV.DecMapInt64Int32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64Int32V(rv2i(rv).(map[int64]int32), false, d)
 }
-func (f fastpathT) DecMapInt64Int32X(vp *map[int64]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Int32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64Int32X(vp *map[int64]int32, d *Decoder) {
+	if v, changed := f.DecMapInt64Int32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, canChange bool,
 	d *Decoder) (_ map[int64]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int64]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]int64)
-		v, changed := fastpathTV.DecMapInt64Int64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int64)
+		if v, changed := fastpathTV.DecMapInt64Int64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]int64)
-		fastpathTV.DecMapInt64Int64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64Int64V(rv2i(rv).(map[int64]int64), false, d)
 }
-func (f fastpathT) DecMapInt64Int64X(vp *map[int64]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Int64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64Int64X(vp *map[int64]int64, d *Decoder) {
+	if v, changed := f.DecMapInt64Int64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, canChange bool,
 	d *Decoder) (_ map[int64]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int64]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]float32)
-		v, changed := fastpathTV.DecMapInt64Float32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]float32)
+		if v, changed := fastpathTV.DecMapInt64Float32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]float32)
-		fastpathTV.DecMapInt64Float32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64Float32V(rv2i(rv).(map[int64]float32), false, d)
 }
-func (f fastpathT) DecMapInt64Float32X(vp *map[int64]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Float32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64Float32X(vp *map[int64]float32, d *Decoder) {
+	if v, changed := f.DecMapInt64Float32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, canChange bool,
 	d *Decoder) (_ map[int64]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 12)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
 		v = make(map[int64]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]float64)
-		v, changed := fastpathTV.DecMapInt64Float64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]float64)
+		if v, changed := fastpathTV.DecMapInt64Float64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]float64)
-		fastpathTV.DecMapInt64Float64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64Float64V(rv2i(rv).(map[int64]float64), false, d)
 }
-func (f fastpathT) DecMapInt64Float64X(vp *map[int64]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Float64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64Float64X(vp *map[int64]float64, d *Decoder) {
+	if v, changed := f.DecMapInt64Float64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, canChange bool,
 	d *Decoder) (_ map[int64]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 16)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
 		v = make(map[int64]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[int64]bool)
-		v, changed := fastpathTV.DecMapInt64BoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]bool)
+		if v, changed := fastpathTV.DecMapInt64BoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[int64]bool)
-		fastpathTV.DecMapInt64BoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapInt64BoolV(rv2i(rv).(map[int64]bool), false, d)
 }
-func (f fastpathT) DecMapInt64BoolX(vp *map[int64]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64BoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapInt64BoolX(vp *map[int64]bool, d *Decoder) {
+	if v, changed := f.DecMapInt64BoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, canChange bool,
 	d *Decoder) (_ map[int64]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[int64]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk int64
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeInt(64)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeInt(64)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]interface{})
-		v, changed := fastpathTV.DecMapBoolIntfV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]interface{})
+		if v, changed := fastpathTV.DecMapBoolIntfV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]interface{})
-		fastpathTV.DecMapBoolIntfV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolIntfV(rv2i(rv).(map[bool]interface{}), false, d)
 }
-func (f fastpathT) DecMapBoolIntfX(vp *map[bool]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolIntfV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolIntfX(vp *map[bool]interface{}, d *Decoder) {
+	if v, changed := f.DecMapBoolIntfV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, canChange bool,
 	d *Decoder) (_ map[bool]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[bool]interface{}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk bool
 	var mv interface{}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
-			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			if mapGet {
-				mv = v[mk]
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
 			} else {
-				mv = nil
-			}
-			d.decode(&mv)
-			if v != nil {
-				v[mk] = mv
+				v[mk] = nil
 			}
+			continue
+		}
+		if mapGet {
+			mv = v[mk]
+		} else {
+			mv = nil
+		}
+		d.decode(&mv)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]string)
-		v, changed := fastpathTV.DecMapBoolStringV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]string)
+		if v, changed := fastpathTV.DecMapBoolStringV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]string)
-		fastpathTV.DecMapBoolStringV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolStringV(rv2i(rv).(map[bool]string), false, d)
 }
-func (f fastpathT) DecMapBoolStringX(vp *map[bool]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolStringV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolStringX(vp *map[bool]string, d *Decoder) {
+	if v, changed := f.DecMapBoolStringV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolStringV(v map[bool]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolStringV(v map[bool]string, canChange bool,
 	d *Decoder) (_ map[bool]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 17)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
 		v = make(map[bool]string, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv string
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeString()
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
 			}
+			continue
+		}
+		mv = dd.DecodeString()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]uint)
-		v, changed := fastpathTV.DecMapBoolUintV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint)
+		if v, changed := fastpathTV.DecMapBoolUintV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]uint)
-		fastpathTV.DecMapBoolUintV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolUintV(rv2i(rv).(map[bool]uint), false, d)
 }
-func (f fastpathT) DecMapBoolUintX(vp *map[bool]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUintV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolUintX(vp *map[bool]uint, d *Decoder) {
+	if v, changed := f.DecMapBoolUintV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, canChange bool,
 	d *Decoder) (_ map[bool]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[bool]uint, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv uint
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]uint8)
-		v, changed := fastpathTV.DecMapBoolUint8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint8)
+		if v, changed := fastpathTV.DecMapBoolUint8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]uint8)
-		fastpathTV.DecMapBoolUint8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolUint8V(rv2i(rv).(map[bool]uint8), false, d)
 }
-func (f fastpathT) DecMapBoolUint8X(vp *map[bool]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUint8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolUint8X(vp *map[bool]uint8, d *Decoder) {
+	if v, changed := f.DecMapBoolUint8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, canChange bool,
 	d *Decoder) (_ map[bool]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
 		v = make(map[bool]uint8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv uint8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint8(dd.DecodeUint(8))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(dd.DecodeUint(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]uint16)
-		v, changed := fastpathTV.DecMapBoolUint16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint16)
+		if v, changed := fastpathTV.DecMapBoolUint16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]uint16)
-		fastpathTV.DecMapBoolUint16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolUint16V(rv2i(rv).(map[bool]uint16), false, d)
 }
-func (f fastpathT) DecMapBoolUint16X(vp *map[bool]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUint16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolUint16X(vp *map[bool]uint16, d *Decoder) {
+	if v, changed := f.DecMapBoolUint16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, canChange bool,
 	d *Decoder) (_ map[bool]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[bool]uint16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv uint16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint16(dd.DecodeUint(16))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(dd.DecodeUint(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]uint32)
-		v, changed := fastpathTV.DecMapBoolUint32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint32)
+		if v, changed := fastpathTV.DecMapBoolUint32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]uint32)
-		fastpathTV.DecMapBoolUint32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolUint32V(rv2i(rv).(map[bool]uint32), false, d)
 }
-func (f fastpathT) DecMapBoolUint32X(vp *map[bool]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUint32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolUint32X(vp *map[bool]uint32, d *Decoder) {
+	if v, changed := f.DecMapBoolUint32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, canChange bool,
 	d *Decoder) (_ map[bool]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[bool]uint32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv uint32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uint32(dd.DecodeUint(32))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(dd.DecodeUint(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]uint64)
-		v, changed := fastpathTV.DecMapBoolUint64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint64)
+		if v, changed := fastpathTV.DecMapBoolUint64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]uint64)
-		fastpathTV.DecMapBoolUint64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolUint64V(rv2i(rv).(map[bool]uint64), false, d)
 }
-func (f fastpathT) DecMapBoolUint64X(vp *map[bool]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUint64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolUint64X(vp *map[bool]uint64, d *Decoder) {
+	if v, changed := f.DecMapBoolUint64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, canChange bool,
 	d *Decoder) (_ map[bool]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[bool]uint64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv uint64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeUint(64)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]uintptr)
-		v, changed := fastpathTV.DecMapBoolUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uintptr)
+		if v, changed := fastpathTV.DecMapBoolUintptrV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]uintptr)
-		fastpathTV.DecMapBoolUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), false, d)
 }
-func (f fastpathT) DecMapBoolUintptrX(vp *map[bool]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUintptrV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolUintptrX(vp *map[bool]uintptr, d *Decoder) {
+	if v, changed := f.DecMapBoolUintptrV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, canChange bool,
 	d *Decoder) (_ map[bool]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[bool]uintptr, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv uintptr
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = uintptr(dd.DecodeUint(uintBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(dd.DecodeUint(uintBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]int)
-		v, changed := fastpathTV.DecMapBoolIntV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int)
+		if v, changed := fastpathTV.DecMapBoolIntV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]int)
-		fastpathTV.DecMapBoolIntV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolIntV(rv2i(rv).(map[bool]int), false, d)
 }
-func (f fastpathT) DecMapBoolIntX(vp *map[bool]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolIntV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolIntX(vp *map[bool]int, d *Decoder) {
+	if v, changed := f.DecMapBoolIntV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolIntV(v map[bool]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolIntV(v map[bool]int, canChange bool,
 	d *Decoder) (_ map[bool]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[bool]int, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv int
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int(dd.DecodeInt(intBitsize))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(dd.DecodeInt(intBitsize))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]int8)
-		v, changed := fastpathTV.DecMapBoolInt8V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int8)
+		if v, changed := fastpathTV.DecMapBoolInt8V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]int8)
-		fastpathTV.DecMapBoolInt8V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolInt8V(rv2i(rv).(map[bool]int8), false, d)
 }
-func (f fastpathT) DecMapBoolInt8X(vp *map[bool]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolInt8V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolInt8X(vp *map[bool]int8, d *Decoder) {
+	if v, changed := f.DecMapBoolInt8V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, canChange bool,
 	d *Decoder) (_ map[bool]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
 		v = make(map[bool]int8, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv int8
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int8(dd.DecodeInt(8))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(dd.DecodeInt(8))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]int16)
-		v, changed := fastpathTV.DecMapBoolInt16V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int16)
+		if v, changed := fastpathTV.DecMapBoolInt16V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]int16)
-		fastpathTV.DecMapBoolInt16V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolInt16V(rv2i(rv).(map[bool]int16), false, d)
 }
-func (f fastpathT) DecMapBoolInt16X(vp *map[bool]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolInt16V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolInt16X(vp *map[bool]int16, d *Decoder) {
+	if v, changed := f.DecMapBoolInt16V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, canChange bool,
 	d *Decoder) (_ map[bool]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 3)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
 		v = make(map[bool]int16, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv int16
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int16(dd.DecodeInt(16))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(dd.DecodeInt(16))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]int32)
-		v, changed := fastpathTV.DecMapBoolInt32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int32)
+		if v, changed := fastpathTV.DecMapBoolInt32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]int32)
-		fastpathTV.DecMapBoolInt32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolInt32V(rv2i(rv).(map[bool]int32), false, d)
 }
-func (f fastpathT) DecMapBoolInt32X(vp *map[bool]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolInt32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolInt32X(vp *map[bool]int32, d *Decoder) {
+	if v, changed := f.DecMapBoolInt32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, canChange bool,
 	d *Decoder) (_ map[bool]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[bool]int32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv int32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = int32(dd.DecodeInt(32))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(dd.DecodeInt(32))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]int64)
-		v, changed := fastpathTV.DecMapBoolInt64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int64)
+		if v, changed := fastpathTV.DecMapBoolInt64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]int64)
-		fastpathTV.DecMapBoolInt64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolInt64V(rv2i(rv).(map[bool]int64), false, d)
 }
-func (f fastpathT) DecMapBoolInt64X(vp *map[bool]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolInt64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolInt64X(vp *map[bool]int64, d *Decoder) {
+	if v, changed := f.DecMapBoolInt64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, canChange bool,
 	d *Decoder) (_ map[bool]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[bool]int64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv int64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeInt(64)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt(64)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]float32)
-		v, changed := fastpathTV.DecMapBoolFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]float32)
+		if v, changed := fastpathTV.DecMapBoolFloat32V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]float32)
-		fastpathTV.DecMapBoolFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolFloat32V(rv2i(rv).(map[bool]float32), false, d)
 }
-func (f fastpathT) DecMapBoolFloat32X(vp *map[bool]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolFloat32V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolFloat32X(vp *map[bool]float32, d *Decoder) {
+	if v, changed := f.DecMapBoolFloat32V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, canChange bool,
 	d *Decoder) (_ map[bool]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 5)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
 		v = make(map[bool]float32, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv float32
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = float32(dd.DecodeFloat(true))
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(dd.DecodeFloat(true))
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]float64)
-		v, changed := fastpathTV.DecMapBoolFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]float64)
+		if v, changed := fastpathTV.DecMapBoolFloat64V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]float64)
-		fastpathTV.DecMapBoolFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolFloat64V(rv2i(rv).(map[bool]float64), false, d)
 }
-func (f fastpathT) DecMapBoolFloat64X(vp *map[bool]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolFloat64V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolFloat64X(vp *map[bool]float64, d *Decoder) {
+	if v, changed := f.DecMapBoolFloat64V(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, canChange bool,
 	d *Decoder) (_ map[bool]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 9)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
 		v = make(map[bool]float64, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv float64
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeFloat(false)
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat(false)
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[bool]bool)
-		v, changed := fastpathTV.DecMapBoolBoolV(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) fastpathDecMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]bool)
+		if v, changed := fastpathTV.DecMapBoolBoolV(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[bool]bool)
-		fastpathTV.DecMapBoolBoolV(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.DecMapBoolBoolV(rv2i(rv).(map[bool]bool), false, d)
 }
-func (f fastpathT) DecMapBoolBoolX(vp *map[bool]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolBoolV(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) DecMapBoolBoolX(vp *map[bool]bool, d *Decoder) {
+	if v, changed := f.DecMapBoolBoolV(*vp, true, d); changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, canChange bool,
 	d *Decoder) (_ map[bool]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, 2)
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
 		v = make(map[bool]bool, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 
 	var mk bool
 	var mv bool
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep {
+			dd.ReadMapElemKey()
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			mk = dd.DecodeBool()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			mv = dd.DecodeBool()
-			if v != nil {
-				v[mk] = mv
+		mk = dd.DecodeBool()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
 			}
+			continue
+		}
+		mv = dd.DecodeBool()
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
diff --git a/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl b/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
index c3ffdf93d96..eebc31b38f1 100644
--- a/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
@@ -40,9 +40,6 @@ import (
 
 const fastpathEnabled = true
 
-const fastpathCheckNilFalse = false // for reflect
-const fastpathCheckNilTrue = true // for type switch
-
 type fastpathT struct {}
 
 var fastpathTV fastpathT
@@ -50,8 +47,8 @@ var fastpathTV fastpathT
 type fastpathE struct {
 	rtid uintptr
 	rt reflect.Type 
-	encfn func(*encFnInfo, reflect.Value)
-	decfn func(*decFnInfo, reflect.Value)
+	encfn func(*Encoder, *codecFnInfo, reflect.Value)
+	decfn func(*Decoder, *codecFnInfo, reflect.Value)
 }
 
 type fastpathA [{{ .FastpathLen }}]fastpathE
@@ -84,19 +81,25 @@ var fastpathAV fastpathA
 // due to possible initialization loop error, make fastpath in an init()
 func init() {
 	i := 0
-	fn := func(v interface{}, fe func(*encFnInfo, reflect.Value), fd func(*decFnInfo, reflect.Value)) (f fastpathE) {
+	fn := func(v interface{},
+		fe func(*Encoder, *codecFnInfo, reflect.Value),
+		fd func(*Decoder, *codecFnInfo, reflect.Value)) (f fastpathE) {
 		xrt := reflect.TypeOf(v)
-		xptr := reflect.ValueOf(xrt).Pointer()
+		xptr := rt2id(xrt)
+		if useLookupRecognizedTypes {
+			recognizedRtids = append(recognizedRtids, xptr)
+			recognizedRtidPtrs = append(recognizedRtidPtrs, rt2id(reflect.PtrTo(xrt)))
+		}
 		fastpathAV[i] = fastpathE{xptr, xrt, fe, fd}
 		i++
 		return
 	}
 	
 	{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
-	fn([]{{ .Elem }}(nil), (*encFnInfo).{{ .MethodNamePfx "fastpathEnc" false }}R, (*decFnInfo).{{ .MethodNamePfx "fastpathDec" false }}R){{end}}{{end}}{{end}}
+	fn([]{{ .Elem }}(nil), (*Encoder).{{ .MethodNamePfx "fastpathEnc" false }}R, (*Decoder).{{ .MethodNamePfx "fastpathDec" false }}R){{end}}{{end}}{{end}}
 	
 	{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
-	fn(map[{{ .MapKey }}]{{ .Elem }}(nil), (*encFnInfo).{{ .MethodNamePfx "fastpathEnc" false }}R, (*decFnInfo).{{ .MethodNamePfx "fastpathDec" false }}R){{end}}{{end}}{{end}}
+	fn(map[{{ .MapKey }}]{{ .Elem }}(nil), (*Encoder).{{ .MethodNamePfx "fastpathEnc" false }}R, (*Decoder).{{ .MethodNamePfx "fastpathDec" false }}R){{end}}{{end}}{{end}}
 	
 	sort.Sort(fastpathAslice(fastpathAV[:]))
 }
@@ -109,10 +112,10 @@ func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
 {{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
 	case []{{ .Elem }}:{{else}}
 	case map[{{ .MapKey }}]{{ .Elem }}:{{end}}
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, fastpathCheckNilTrue, e){{if not .MapKey }}
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, e){{if not .MapKey }}
 	case *[]{{ .Elem }}:{{else}}
 	case *map[{{ .MapKey }}]{{ .Elem }}:{{end}}
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, e)
 {{end}}{{end}}
 	default:
         _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
@@ -125,9 +128,9 @@ func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
 	switch v := iv.(type) {
 {{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
 	case []{{ .Elem }}:
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, fastpathCheckNilTrue, e)
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, e)
 	case *[]{{ .Elem }}:
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, e)
 {{end}}{{end}}{{end}}
 	default:
         _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
@@ -140,9 +143,9 @@ func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
 	switch v := iv.(type) {
 {{range .Values}}{{if not .Primitive}}{{if .MapKey }}
 	case map[{{ .MapKey }}]{{ .Elem }}:
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, fastpathCheckNilTrue, e)
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, e)
 	case *map[{{ .MapKey }}]{{ .Elem }}:
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e)
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, e)
 {{end}}{{end}}{{end}}
 	default:
         _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
@@ -154,68 +157,53 @@ func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
 // -- -- fast path functions
 {{range .Values}}{{if not .Primitive}}{{if not .MapKey }} 
 
-func (f *encFnInfo) {{ .MethodNamePfx "fastpathEnc" false }}R(rv reflect.Value) {
+func (e *Encoder) {{ .MethodNamePfx "fastpathEnc" false }}R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.{{ .MethodNamePfx "EncAsMap" false }}V(rv.Interface().([]{{ .Elem }}), fastpathCheckNilFalse, f.e)
+		fastpathTV.{{ .MethodNamePfx "EncAsMap" false }}V(rv2i(rv).([]{{ .Elem }}), e)
 	} else {
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv.Interface().([]{{ .Elem }}), fastpathCheckNilFalse, f.e)
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv2i(rv).([]{{ .Elem }}), e)
 	}
 }
-func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v []{{ .Elem }}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
+func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v []{{ .Elem }}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil { cr.sendContainerState(containerArrayElem) }
+		if esep { ee.WriteArrayElem() }
 		{{ encmd .Elem "v2"}}
 	}
-	if cr != nil { cr.sendContainerState(containerArrayEnd) }{{/* ee.EncodeEnd() */}}
+	ee.WriteArrayEnd()
 }
 
-func (_ fastpathT) {{ .MethodNamePfx "EncAsMap" false }}V(v []{{ .Elem }}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) {{ .MethodNamePfx "EncAsMap" false }}V(v []{{ .Elem }}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		{{ encmd .Elem "v2"}}
 	}
-	if cr != nil { cr.sendContainerState(containerMapEnd) }
+	ee.WriteMapEnd()
 }
 
 {{end}}{{end}}{{end}}
 
 {{range .Values}}{{if not .Primitive}}{{if .MapKey }}
 
-func (f *encFnInfo) {{ .MethodNamePfx "fastpathEnc" false }}R(rv reflect.Value) {
-	fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv.Interface().(map[{{ .MapKey }}]{{ .Elem }}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) {{ .MethodNamePfx "fastpathEnc" false }}R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv2i(rv).(map[{{ .MapKey }}]{{ .Elem }}), e)
 }
-func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
+func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators() 
+	ee.WriteMapStart(len(v))
 	{{if eq .MapKey "string"}}asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	{{end}}if e.h.Canonical {
 		{{if eq .MapKey "interface{}"}}{{/* out of band 
@@ -234,9 +222,9 @@ func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Ele
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil { cr.sendContainerState(containerMapKey) }
+			if esep { ee.WriteMapElemKey() }
 			e.asis(v2[j].v)
-			if cr != nil { cr.sendContainerState(containerMapValue) }
+			if esep { ee.WriteMapElemValue() }
 			e.encode(v[v2[j].i])
 		} {{else}}{{ $x := sorttype .MapKey true}}v2 := make([]{{ $x }}, len(v))
 		var i int 
@@ -246,28 +234,28 @@ func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Ele
 		}
 		sort.Sort({{ sorttype .MapKey false}}(v2))
 		for _, k2 := range v2 {
-			if cr != nil { cr.sendContainerState(containerMapKey) }
+			if esep { ee.WriteMapElemKey() }
 			{{if eq .MapKey "string"}}if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}{{else}}{{ $y := printf "%s(k2)" .MapKey }}{{ encmd .MapKey $y }}{{end}}
-			if cr != nil { cr.sendContainerState(containerMapValue) }
+			if esep { ee.WriteMapElemValue() }
 			{{ $y := printf "v[%s(k2)]" .MapKey }}{{ encmd .Elem $y }}
 		} {{end}}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil { cr.sendContainerState(containerMapKey) }
+			if esep { ee.WriteMapElemKey() }
 			{{if eq .MapKey "string"}}if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
 				ee.EncodeString(c_UTF8, k2)
 			}{{else}}{{ encmd .MapKey "k2"}}{{end}}
-			if cr != nil { cr.sendContainerState(containerMapValue) }
+			if esep { ee.WriteMapElemValue() }
 			{{ encmd .Elem "v2"}}
 		}
 	}
-	if cr != nil { cr.sendContainerState(containerMapEnd) }{{/* ee.EncodeEnd() */}}
+	ee.WriteMapEnd()
 }
 
 {{end}}{{end}}{{end}}
@@ -280,11 +268,10 @@ func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
 {{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
 	case []{{ .Elem }}:{{else}}
 	case map[{{ .MapKey }}]{{ .Elem }}:{{end}}
-		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, d){{if not .MapKey }}
-	case *[]{{ .Elem }}:{{else}}
-	case *map[{{ .MapKey }}]{{ .Elem }}:{{end}}
-		v2, changed2 := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, false, d){{if not .MapKey }}
+	case *[]{{ .Elem }}: {{else}}
+	case *map[{{ .MapKey }}]{{ .Elem }}: {{end}}
+		if v2, changed2 := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*v, true, d); changed2 {
 			*v = v2 
 		}
 {{end}}{{end}}
@@ -295,6 +282,20 @@ func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
 	return true
 }
 
+func fastpathDecodeSetZeroTypeSwitch(iv interface{}, d *Decoder) bool {
+	switch v := iv.(type) {
+{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
+	case *[]{{ .Elem }}: {{else}}
+	case *map[{{ .MapKey }}]{{ .Elem }}: {{end}}
+		*v = nil 
+{{end}}{{end}}
+	default:
+        _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
+		return false
+	}
+	return true
+}
+
 // -- -- fast path functions
 {{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
 {{/*
@@ -303,40 +304,29 @@ Slices can change if they
 - are addressable (from a ptr)
 - are settable (e.g. contained in an interface{})
 */}}
-func (f *decFnInfo) {{ .MethodNamePfx "fastpathDec" false }}R(rv reflect.Value) { 
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() { {{/* // CanSet => CanAddr + Exported */}}
-		vp := rv.Addr().Interface().(*[]{{ .Elem }})
-		v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
-			*vp = v
+func (d *Decoder) {{ .MethodNamePfx "fastpathDec" false }}R(f *codecFnInfo, rv reflect.Value) { 
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		var vp = rv2i(rv).(*[]{{ .Elem }})
+		if v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*vp, !array, d); changed {
+				*vp = v
 		}
 	} else {
-		v := rv.Interface().([]{{ .Elem }})
-		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(rv2i(rv).([]{{ .Elem }}), !array, d)
 	}
 }
 
-func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *[]{{ .Elem }}, checkNil bool, d *Decoder) {
-	v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *[]{{ .Elem }}, d *Decoder) {
+	if v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, true, d); changed {
 		*vp = v 
 	}
 }
-func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, checkNil bool, canChange bool, d *Decoder) (_ []{{ .Elem }}, changed bool) {
+func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, canChange bool, d *Decoder) (_ []{{ .Elem }}, changed bool) {
 	dd := d.d
 	{{/* // if dd.isContainerType(valueTypeNil) { dd.TryDecodeAsNil() */}}
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true 
-		}
-		return nil, changed 
-	}
-
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
-			if v == nil {
+			if v == nil { 
 				v = []{{ .Elem }}{}
 			} else if len(v) != 0 {
 				v = v[:0]
@@ -346,98 +336,62 @@ func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, checkNil b
 		slh.End()
 		return v, changed
 	}
-	
-	if containerLenS > 0 {
-		x2read := containerLenS
-		var xtrunc bool 
+
+	hasLen := containerLenS > 0
+	var xlen int 
+	if hasLen && canChange {
 		if containerLenS > cap(v) {
-			if canChange { {{/*
-				// fast-path is for "basic" immutable types, so no need to copy them over
-				// s := make([]{{ .Elem }}, decInferLen(containerLenS, d.h.MaxInitLen))
-				// copy(s, v[:cap(v)])
-				// v = s */}}
-				var xlen int 
-                xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }})
-				if xtrunc {
-					if xlen <= cap(v) {
-						v = v[:xlen]
-					} else {
-						v = make([]{{ .Elem }}, xlen)
-					}
-				} else {
-					v = make([]{{ .Elem }}, xlen)
-				}
-				changed = true
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }})
+			if xlen <= cap(v) {
+				v = v[:xlen]
 			} else {
-				d.arrayCannotExpand(len(v), containerLenS)
+				v = make([]{{ .Elem }}, xlen)
 			}
-			x2read = len(v)
+			changed = true 
 		} else if containerLenS != len(v) {
-			if canChange {
-				v = v[:containerLenS]
-				changed = true
-			}
-		} {{/* // all checks done. cannot go past len. */}}
-		j := 0
-		for ; j < x2read; j++ {
-			slh.ElemContainerState(j)
-			{{ if eq .Elem "interface{}" }}d.decode(&v[j]){{ else }}v[j] = {{ decmd .Elem }}{{ end }}
-		}
-		if xtrunc { {{/* // means canChange=true, changed=true already. */}}
-			for ; j < containerLenS; j++ {
-				v = append(v, {{ zerocmd .Elem }})
-				slh.ElemContainerState(j)
-				{{ if eq .Elem "interface{}" }}d.decode(&v[j]){{ else }}v[j] = {{ decmd .Elem }}{{ end }}
-			}
-		} else if !canChange {
-			for ; j < containerLenS; j++ {
-				slh.ElemContainerState(j)
-				d.swallow()
-			}
-		}
-	} else {
-		breakFound := dd.CheckBreak() {{/* check break first, so we can initialize v with a capacity of 4 if necessary */}}
-		if breakFound {
-			if canChange {
-				if v == nil {
-					v = []{{ .Elem }}{}
-				} else if len(v) != 0 {
-					v = v[:0]
-				}
-				changed = true
-			}
-			slh.End()
-			return v, changed
-		}
-		if cap(v) == 0 {
-			v = make([]{{ .Elem }}, 1, 4)
-			changed = true
-		}
-		j := 0	
-		for ; !breakFound; j++ {
-			if j >= len(v) { 
-				if canChange {
-					v = append(v, {{ zerocmd .Elem }})
-					changed = true
-				} else {
-					d.arrayCannotExpand(len(v), j+1)
-				}
-			}
-			slh.ElemContainerState(j)
-			if j < len(v) { {{/* // all checks done. cannot go past len. */}}
-				{{ if eq .Elem "interface{}" }}d.decode(&v[j])
-				{{ else }}v[j] = {{ decmd .Elem }}{{ end }}
-			} else {
-				d.swallow()
-			}
-			breakFound = dd.CheckBreak()
-		}
-		if canChange && j < len(v) {
-			v = v[:j]
+			v = v[:containerLenS]
 			changed = true
 		}
 	}
-	slh.End() 
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }})
+			} else {
+				xlen = 8
+			}
+			v = make([]{{ .Elem }}, xlen)
+			changed = true 
+		}
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, {{ zerocmd .Elem }})
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else {
+			{{ if eq .Elem "interface{}" }}d.decode(&v[j]){{ else }}v[j] = {{ decmd .Elem }}{{ end }}
+		}
+	}
+	if canChange {
+		if j < len(v) {
+			v = v[:j]
+			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]{{ .Elem }}, 0)
+			changed = true
+		}
+	}
+	slh.End()
 	return v, changed 
 }
 
@@ -450,77 +404,58 @@ Maps can change if they are
 - addressable (from a ptr)
 - settable (e.g. contained in an interface{})
 */}}
-func (f *decFnInfo) {{ .MethodNamePfx "fastpathDec" false }}R(rv reflect.Value) { 
-	if rv.CanAddr() {
-		vp := rv.Addr().Interface().(*map[{{ .MapKey }}]{{ .Elem }})
-		v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
+func (d *Decoder) {{ .MethodNamePfx "fastpathDec" false }}R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[{{ .MapKey }}]{{ .Elem }})
+		if v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*vp, true, d); changed {
 			*vp = v
 		}
-	} else {
-		v := rv.Interface().(map[{{ .MapKey }}]{{ .Elem }})
-		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, f.d)
+		return
 	}
+	fastpathTV.{{ .MethodNamePfx "Dec" false }}V(rv2i(rv).(map[{{ .MapKey }}]{{ .Elem }}), false, d)
 }
-func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, d *Decoder) {
-	v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, checkNil, true, d)
-	if changed {
+func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *map[{{ .MapKey }}]{{ .Elem }}, d *Decoder) {
+	if v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, true, d); changed {
 		*vp = v 
 	}
 }
-func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, canChange bool, 
+func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, canChange bool, 
 	d *Decoder) (_ map[{{ .MapKey }}]{{ .Elem }}, changed bool) {
-	dd := d.d
-	cr := d.cr
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	{{/* // if dd.isContainerType(valueTypeNil) {dd.TryDecodeAsNil() */}}
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		} 
-		return nil, changed
-	}
-
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
-		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, {{ .Size }})
+		xlen := decInferLen(containerLen, d.h.MaxInitLen, {{ .Size }})
 		v = make(map[{{ .MapKey }}]{{ .Elem }}, xlen)
 		changed = true
 	}
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
 	{{ if eq .Elem "interface{}" }}mapGet := !d.h.MapValueReset && !d.h.InterfaceReset{{end}}
 	var mk {{ .MapKey }}
 	var mv {{ .Elem }}
-	if containerLen > 0 {
-		for j := 0; j < containerLen; j++ {
-			if cr != nil { cr.sendContainerState(containerMapKey) }
-			{{ if eq .MapKey "interface{}" }}mk = nil 
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv) {{/* // maps cannot have []byte as key. switch to string. */}}
-			}{{ else }}mk = {{ decmd .MapKey }}{{ end }}
-			if cr != nil { cr.sendContainerState(containerMapValue) }
-			{{ if eq .Elem "interface{}" }}if mapGet { mv = v[mk] } else { mv = nil }
-			d.decode(&mv){{ else }}mv = {{ decmd .Elem }}{{ end }}
-			if v != nil {
-				v[mk] = mv
-			}
+	hasLen := containerLen > 0
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if esep { dd.ReadMapElemKey() }
+		{{ if eq .MapKey "interface{}" }}mk = nil 
+		d.decode(&mk)
+		if bv, bok := mk.([]byte); bok {
+			mk = d.string(bv) {{/* // maps cannot have []byte as key. switch to string. */}}
+		}{{ else }}mk = {{ decmd .MapKey }}{{ end }}
+		if esep { dd.ReadMapElemValue() }
+		if dd.TryDecodeAsNil() {
+			if d.h.DeleteOnNilMapValue { delete(v, mk) } else { v[mk] = {{ zerocmd .Elem }} }
+			continue 
 		}
-	} else if containerLen < 0 {
-		for j := 0; !dd.CheckBreak(); j++ {
-			if cr != nil { cr.sendContainerState(containerMapKey) }
-			{{ if eq .MapKey "interface{}" }}mk = nil 
-			d.decode(&mk)
-			if bv, bok := mk.([]byte); bok {
-				mk = d.string(bv) {{/* // maps cannot have []byte as key. switch to string. */}}
-			}{{ else }}mk = {{ decmd .MapKey }}{{ end }}
-			if cr != nil { cr.sendContainerState(containerMapValue) }
-			{{ if eq .Elem "interface{}" }}if mapGet { mv = v[mk] } else { mv = nil }
-			d.decode(&mv){{ else }}mv = {{ decmd .Elem }}{{ end }}
-			if v != nil {
-				v[mk] = mv
-			}
+		{{ if eq .Elem "interface{}" }}if mapGet { mv = v[mk] } else { mv = nil }
+		d.decode(&mv){{ else }}mv = {{ decmd .Elem }}{{ end }}
+		if v != nil {
+			v[mk] = mv
 		}
 	}
-	if cr != nil { cr.sendContainerState(containerMapEnd) }
+	dd.ReadMapEnd()
 	return v, changed
 }
 
diff --git a/vendor/github.com/ugorji/go/codec/fast-path.not.go b/vendor/github.com/ugorji/go/codec/fast-path.not.go
index 63e59114529..9573d64ab01 100644
--- a/vendor/github.com/ugorji/go/codec/fast-path.not.go
+++ b/vendor/github.com/ugorji/go/codec/fast-path.not.go
@@ -14,17 +14,18 @@ const fastpathEnabled = false
 // This tag disables fastpath during build, allowing for faster build, test execution,
 // short-program runs, etc.
 
-func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool      { return false }
-func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool      { return false }
-func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { return false }
-func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool   { return false }
+func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool        { return false }
+func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool        { return false }
+func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool   { return false }
+func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool     { return false }
+func fastpathDecodeSetZeroTypeSwitch(iv interface{}, d *Decoder) bool { return false }
 
 type fastpathT struct{}
 type fastpathE struct {
 	rtid  uintptr
 	rt    reflect.Type
-	encfn func(*encFnInfo, reflect.Value)
-	decfn func(*decFnInfo, reflect.Value)
+	encfn func(*Encoder, *codecFnInfo, reflect.Value)
+	decfn func(*Decoder, *codecFnInfo, reflect.Value)
 }
 type fastpathA [0]fastpathE
 
diff --git a/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
index 32df54144ca..d9940c0ad6f 100644
--- a/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
@@ -13,92 +13,65 @@ if {{var "l"}} == 0 {
 		{{var "v"}} = make({{ .CTyp }}, 0)
 		{{var "c"}} = true
 	} {{end}}
-} else if {{var "l"}} > 0 {
-	{{if isChan }}if {{var "v"}} == nil {
-		{{var "rl"}}, _ = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
-		{{var "v"}} = make({{ .CTyp }}, {{var "rl"}})
-		{{var "c"}} = true
-	}
-	for {{var "r"}} := 0; {{var "r"}} < {{var "l"}}; {{var "r"}}++ {
-		{{var "h"}}.ElemContainerState({{var "r"}})
-		var {{var "t"}} {{ .Typ }}
-		{{ $x := printf "%st%s" .TempVar .Rand }}{{ decLineVar $x }}
-		{{var "v"}} <- {{var "t"}}
-	}
-	{{ else }}	var {{var "rr"}}, {{var "rl"}} int {{/* // num2read, length of slice/array/chan */}}
-	var {{var "rt"}} bool {{/* truncated */}}
-	_, _ = {{var "rl"}}, {{var "rt"}}
-	{{var "rr"}} = {{var "l"}} // len({{var "v"}})
+} else {
+	{{var "hl"}} := {{var "l"}} > 0
+	var {{var "rl"}} int; _ =  {{var "rl"}}
+	{{if isSlice }} if {{var "hl"}} {
 	if {{var "l"}} > cap({{var "v"}}) {
-		{{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "l"}})
-		{{ else }}{{if not .Immutable }}
-		{{var "rg"}} := len({{var "v"}}) > 0
-		{{var "v2"}} := {{var "v"}} {{end}}
-		{{var "rl"}}, {{var "rt"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
-		if {{var "rt"}} {
-			if {{var "rl"}} <= cap({{var "v"}}) {
-				{{var "v"}} = {{var "v"}}[:{{var "rl"}}]
-			} else {
-				{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
-			}
+		{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+		if {{var "rl"}} <= cap({{var "v"}}) {
+			{{var "v"}} = {{var "v"}}[:{{var "rl"}}]
 		} else {
 			{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
 		}
 		{{var "c"}} = true
-		{{var "rr"}} = len({{var "v"}}) {{if not .Immutable }}
-			if {{var "rg"}} { copy({{var "v"}}, {{var "v2"}}) } {{end}} {{end}}{{/* end not Immutable, isArray */}}
-	} {{if isSlice }} else if {{var "l"}} != len({{var "v"}}) {
+	} else if {{var "l"}} != len({{var "v"}}) {
 		{{var "v"}} = {{var "v"}}[:{{var "l"}}]
 		{{var "c"}} = true
-	} {{end}}	{{/* end isSlice:47 */}} 
-	{{var "j"}} := 0
-	for ; {{var "j"}} < {{var "rr"}} ; {{var "j"}}++ {
-		{{var "h"}}.ElemContainerState({{var "j"}})
-		{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }}
 	}
-	{{if isArray }}for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ {
+	} {{end}}
+	var {{var "j"}} int 
+    // var {{var "dn"}} bool 
+	for ; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ {
+		{{if not isArray}} if {{var "j"}} == 0 && len({{var "v"}}) == 0 {
+			if {{var "hl"}} {
+				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+			} else {
+				{{var "rl"}} = 8
+			}
+			{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
+			{{var "c"}} = true 
+		}{{end}}
 		{{var "h"}}.ElemContainerState({{var "j"}})
-		z.DecSwallow()
-	}
-	{{ else }}if {{var "rt"}} {
-		for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ {
-			{{var "v"}} = append({{var "v"}}, {{ zero}})
-			{{var "h"}}.ElemContainerState({{var "j"}})
-			{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }}
-		}
-	} {{end}} {{/* end isArray:56 */}}
-	{{end}} {{/* end isChan:16 */}}
-} else { {{/* len < 0 */}}
-	{{var "j"}} := 0
-	for ; !r.CheckBreak(); {{var "j"}}++ {
-		{{if isChan }}
-		{{var "h"}}.ElemContainerState({{var "j"}})
-		var {{var "t"}} {{ .Typ }}
-		{{ $x := printf "%st%s" .TempVar .Rand }}{{ decLineVar $x }}
-		{{var "v"}} <- {{var "t"}} 
-		{{ else }}
+        // {{var "dn"}} = r.TryDecodeAsNil()
+        {{if isChan}}{{ $x := printf "%[1]vv%[2]v" .TempVar .Rand }}var {{var $x}} {{ .Typ }}
+		{{ decLineVar $x }}
+		{{var "v"}} <- {{ $x }}
+        {{else}}
+		// if indefinite, etc, then expand the slice if necessary
+		var {{var "db"}} bool
 		if {{var "j"}} >= len({{var "v"}}) {
-			{{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "j"}}+1)
-			{{ else }}{{var "v"}} = append({{var "v"}}, {{zero}})// var {{var "z"}} {{ .Typ }}
-			{{var "c"}} = true {{end}}
+			{{if isSlice }} {{var "v"}} = append({{var "v"}}, {{ zero }}); {{var "c"}} = true
+			{{else}} z.DecArrayCannotExpand(len(v), {{var "j"}}+1); {{var "db"}} = true
+			{{end}}
 		}
-		{{var "h"}}.ElemContainerState({{var "j"}})
-		if {{var "j"}} < len({{var "v"}}) {
-			{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }}
-		} else {
+		if {{var "db"}} {
 			z.DecSwallow()
+		} else {
+			{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }}
 		}
-		{{end}}
+        {{end}}
 	}
-	{{if isSlice }}if {{var "j"}} < len({{var "v"}}) {
+	{{if isSlice}} if {{var "j"}} < len({{var "v"}}) {
 		{{var "v"}} = {{var "v"}}[:{{var "j"}}]
 		{{var "c"}} = true
 	} else if {{var "j"}} == 0 && {{var "v"}} == nil {
-		{{var "v"}} = []{{ .Typ }}{}
+		{{var "v"}} = make([]{{ .Typ }}, 0)
 		{{var "c"}} = true
-	}{{end}}
+	} {{end}}
 }
 {{var "h"}}.End()
 {{if not isArray }}if {{var "c"}} { 
 	*{{ .Varname }} = {{var "v"}}
 }{{end}}
+
diff --git a/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
index 77400e0a112..8323b54940d 100644
--- a/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
@@ -2,21 +2,22 @@
 {{var "l"}} := r.ReadMapStart()
 {{var "bh"}} := z.DecBasicHandle()
 if {{var "v"}} == nil {
-	{{var "rl"}}, _ := z.DecInferLen({{var "l"}}, {{var "bh"}}.MaxInitLen, {{ .Size }})
+	{{var "rl"}} := z.DecInferLen({{var "l"}}, {{var "bh"}}.MaxInitLen, {{ .Size }})
 	{{var "v"}} = make(map[{{ .KTyp }}]{{ .Typ }}, {{var "rl"}})
 	*{{ .Varname }} = {{var "v"}}
 }
 var {{var "mk"}} {{ .KTyp }}
 var {{var "mv"}} {{ .Typ }}
-var {{var "mg"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
+var {{var "mg"}}, {{var "mdn"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
 if {{var "bh"}}.MapValueReset {
 	{{if decElemKindPtr}}{{var "mg"}} = true
 	{{else if decElemKindIntf}}if !{{var "bh"}}.InterfaceReset { {{var "mg"}} = true }
 	{{else if not decElemKindImmutable}}{{var "mg"}} = true
 	{{end}} }
-if {{var "l"}} > 0  {
-for {{var "j"}} := 0; {{var "j"}} < {{var "l"}}; {{var "j"}}++ {
-	z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }})
+if {{var "l"}} != 0 {
+{{var "hl"}} := {{var "l"}} > 0 
+	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ {
+	r.ReadMapElemKey() {{/* z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) */}}
 	{{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }}
 {{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} {
 		{{var "mk"}} = string({{var "bv"}})
@@ -28,31 +29,14 @@ for {{var "j"}} := 0; {{var "j"}} < {{var "l"}}; {{var "j"}}++ {
 			{{var "ms"}} = false
 		} {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}}
 	} {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}}
-	z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }})
-	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }}
-	if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil {
-		{{var "v"}}[{{var "mk"}}] = {{var "mv"}}
-	}
-}
-} else if {{var "l"}} < 0  {
-for {{var "j"}} := 0; !r.CheckBreak(); {{var "j"}}++ {
-	z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }})
-	{{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }}
-{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} {
-		{{var "mk"}} = string({{var "bv"}})
-	}{{ end }}{{if decElemKindPtr}}
-	{{var "ms"}} = true {{ end }}
-	if {{var "mg"}} {
-		{{if decElemKindPtr}}{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{var "mk"}}] 
-		if {{var "mok"}} {
-			{{var "ms"}} = false
-		} {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}}
-	} {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}}
-	z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }})
-	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }}
-	if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil {
+	r.ReadMapElemValue() {{/* z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }}) */}}
+	{{var "mdn"}} = false
+	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ $y := printf "%vmdn%v" .TempVar .Rand }}{{ decLineVar $x $y }}
+	if {{var "mdn"}} {
+		if {{ var "bh" }}.DeleteOnNilMapValue { delete({{var "v"}}, {{var "mk"}}) } else { {{var "v"}}[{{var "mk"}}] = {{decElemZero}} }
+	} else if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil {
 		{{var "v"}}[{{var "mk"}}] = {{var "mv"}}
 	}
 }
 } // else len==0: TODO: Should we clear map entries?
-z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }})
+r.ReadMapEnd() {{/* z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }}) */}}
diff --git a/vendor/github.com/ugorji/go/codec/gen-helper.generated.go b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go
index eb0bdad3577..9293463deec 100644
--- a/vendor/github.com/ugorji/go/codec/gen-helper.generated.go
+++ b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go
@@ -15,6 +15,9 @@ import (
 	"reflect"
 )
 
+// GenVersion is the current version of codecgen.
+const GenVersion = 8
+
 // This file is used to generate helper code for codecgen.
 // The values here i.e. genHelper(En|De)coder are not to be used directly by
 // library users. They WILL change continuously and without notice.
@@ -26,17 +29,24 @@ import (
 // to perform encoding or decoding of primitives or known slice or map types.
 
 // GenHelperEncoder is exported so that it can be used externally by codecgen.
+//
 // Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
 func GenHelperEncoder(e *Encoder) (genHelperEncoder, encDriver) {
 	return genHelperEncoder{e: e}, e.e
 }
 
 // GenHelperDecoder is exported so that it can be used externally by codecgen.
+//
 // Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
 func GenHelperDecoder(d *Decoder) (genHelperDecoder, decDriver) {
 	return genHelperDecoder{d: d}, d.d
 }
 
+// Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
+func BasicHandleDoNotUse(h Handle) *BasicHandle {
+	return h.getBasicHandle()
+}
+
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 type genHelperEncoder struct {
 	e *Encoder
@@ -56,13 +66,14 @@ func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncBinary() bool {
-	return f.e.be // f.e.hh.isBinaryEncoding()
+	return f.e.cf.be // f.e.hh.isBinaryEncoding()
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncFallback(iv interface{}) {
 	// println(">>>>>>>>> EncFallback")
-	f.e.encodeI(iv, false, false)
+	// f.e.encodeI(iv, false, false)
+	f.e.encodeValue(reflect.ValueOf(iv), nil, false)
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -85,7 +96,7 @@ func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncRaw(iv Raw) {
-	f.e.raw(iv)
+	f.e.rawBytes(iv)
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -98,7 +109,7 @@ func (f genHelperEncoder) TimeRtidIfBinc() uintptr {
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) IsJSONHandle() bool {
-	return f.e.js
+	return f.e.cf.js
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -112,7 +123,7 @@ func (f genHelperEncoder) EncExt(v interface{}) (r bool) {
 	if rt.Kind() == reflect.Ptr {
 		rt = rt.Elem()
 	}
-	rtid := reflect.ValueOf(rt).Pointer()
+	rtid := rt2id(rt)
 	if xfFn := f.e.h.getExt(rtid); xfFn != nil {
 		f.e.e.EncodeExt(v, xfFn.tag, xfFn.ext, f.e)
 		return true
@@ -120,13 +131,6 @@ func (f genHelperEncoder) EncExt(v interface{}) (r bool) {
 	return false
 }
 
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncSendContainerState(c containerState) {
-	if f.e.cr != nil {
-		f.e.cr.sendContainerState(c)
-	}
-}
-
 // ---------------- DECODER FOLLOWS -----------------
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -152,7 +156,12 @@ func (f genHelperDecoder) DecScratchBuffer() []byte {
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecFallback(iv interface{}, chkPtr bool) {
 	// println(">>>>>>>>> DecFallback")
-	f.d.decodeI(iv, chkPtr, false, false, false)
+	rv := reflect.ValueOf(iv)
+	if chkPtr {
+		rv = f.d.ensureDecodeable(rv)
+	}
+	f.d.decodeValue(rv, nil, false, false)
+	// f.d.decodeValueFallback(rv)
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -172,7 +181,7 @@ func (f genHelperDecoder) DecArrayCannotExpand(sliceLen, streamLen int) {
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) {
-	fnerr := tm.UnmarshalText(f.d.d.DecodeBytes(f.d.b[:], true, true))
+	fnerr := tm.UnmarshalText(f.d.d.DecodeStringAsBytes())
 	if fnerr != nil {
 		panic(fnerr)
 	}
@@ -180,7 +189,7 @@ func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) {
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) {
-	// bs := f.dd.DecodeBytes(f.d.b[:], true, true)
+	// bs := f.dd.DecodeStringAsBytes()
 	// grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself.
 	fnerr := tm.UnmarshalJSON(f.d.nextValueBytes())
 	if fnerr != nil {
@@ -190,7 +199,7 @@ func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) {
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecBinaryUnmarshal(bm encoding.BinaryUnmarshaler) {
-	fnerr := bm.UnmarshalBinary(f.d.d.DecodeBytes(nil, false, true))
+	fnerr := bm.UnmarshalBinary(f.d.d.DecodeBytes(nil, true))
 	if fnerr != nil {
 		panic(fnerr)
 	}
@@ -198,7 +207,7 @@ func (f genHelperDecoder) DecBinaryUnmarshal(bm encoding.BinaryUnmarshaler) {
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecRaw() []byte {
-	return f.d.raw()
+	return f.d.rawBytes()
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -222,7 +231,7 @@ func (f genHelperDecoder) HasExtensions() bool {
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecExt(v interface{}) (r bool) {
 	rt := reflect.TypeOf(v).Elem()
-	rtid := reflect.ValueOf(rt).Pointer()
+	rtid := rt2id(rt)
 	if xfFn := f.d.h.getExt(rtid); xfFn != nil {
 		f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
 		return true
@@ -231,13 +240,11 @@ func (f genHelperDecoder) DecExt(v interface{}) (r bool) {
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int, truncated bool) {
+func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int) {
 	return decInferLen(clen, maxlen, unit)
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecSendContainerState(c containerState) {
-	if f.d.cr != nil {
-		f.d.cr.sendContainerState(c)
-	}
+func (f genHelperDecoder) StringView(v []byte) string {
+	return stringView(v)
 }
diff --git a/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
index ad99f6671bd..dfa1def2018 100644
--- a/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
@@ -15,6 +15,9 @@ import (
 	"reflect"
 )
 
+// GenVersion is the current version of codecgen.
+const GenVersion = {{ .Version }} 
+
 // This file is used to generate helper code for codecgen. 
 // The values here i.e. genHelper(En|De)coder are not to be used directly by 
 // library users. They WILL change continuously and without notice.
@@ -26,17 +29,24 @@ import (
 // to perform encoding or decoding of primitives or known slice or map types.
 
 // GenHelperEncoder is exported so that it can be used externally by codecgen.
+// 
 // Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
 func GenHelperEncoder(e *Encoder) (genHelperEncoder, encDriver) {
 	return genHelperEncoder{e:e}, e.e 
 }
 
 // GenHelperDecoder is exported so that it can be used externally by codecgen.
+// 
 // Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
 func GenHelperDecoder(d *Decoder) (genHelperDecoder, decDriver) {
 	return genHelperDecoder{d:d}, d.d 
 }
 
+// Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
+func BasicHandleDoNotUse(h Handle) *BasicHandle {
+     return h.getBasicHandle()
+}
+
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 type genHelperEncoder struct {
 	e *Encoder
@@ -56,12 +66,13 @@ func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncBinary() bool {
-	return f.e.be // f.e.hh.isBinaryEncoding()
+	return f.e.cf.be // f.e.hh.isBinaryEncoding()
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncFallback(iv interface{}) {
 	// println(">>>>>>>>> EncFallback")
-	f.e.encodeI(iv, false, false)
+	// f.e.encodeI(iv, false, false)
+	f.e.encodeValue(reflect.ValueOf(iv), nil, false)
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncTextMarshal(iv encoding.TextMarshaler) {
@@ -80,7 +91,7 @@ func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncRaw(iv Raw) {
-	f.e.raw(iv)
+	f.e.rawBytes(iv)
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) TimeRtidIfBinc() uintptr {
@@ -91,7 +102,7 @@ func (f genHelperEncoder) TimeRtidIfBinc() uintptr {
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) IsJSONHandle() bool {
-	return f.e.js
+	return f.e.cf.js
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) HasExtensions() bool {
@@ -103,19 +114,21 @@ func (f genHelperEncoder) EncExt(v interface{}) (r bool) {
 	if rt.Kind() == reflect.Ptr {
 		rt = rt.Elem()
 	}
-	rtid := reflect.ValueOf(rt).Pointer()
+	rtid := rt2id(rt)
 	if xfFn := f.e.h.getExt(rtid); xfFn != nil {
 		f.e.e.EncodeExt(v, xfFn.tag, xfFn.ext, f.e)
 		return true
 	}
 	return false 
 }
+{{/*
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncSendContainerState(c containerState) {
 	if f.e.cr != nil {
 		f.e.cr.sendContainerState(c)
 	}
 }
+*/}}
 
 // ---------------- DECODER FOLLOWS -----------------
 
@@ -138,7 +151,12 @@ func (f genHelperDecoder) DecScratchBuffer() []byte {
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecFallback(iv interface{}, chkPtr bool) {
 	// println(">>>>>>>>> DecFallback")
-	f.d.decodeI(iv, chkPtr, false, false, false)
+	rv := reflect.ValueOf(iv)
+	if chkPtr {
+		rv = f.d.ensureDecodeable(rv)
+	}
+	f.d.decodeValue(rv, nil, false, false)
+	// f.d.decodeValueFallback(rv)
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecSliceHelperStart() (decSliceHelper, int) {
@@ -154,14 +172,14 @@ func (f genHelperDecoder) DecArrayCannotExpand(sliceLen, streamLen int) {
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) {
-	fnerr := tm.UnmarshalText(f.d.d.DecodeBytes(f.d.b[:], true, true))
+	fnerr := tm.UnmarshalText(f.d.d.DecodeStringAsBytes())
 	if fnerr != nil {
 		panic(fnerr)
 	}
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) {
-	// bs := f.dd.DecodeBytes(f.d.b[:], true, true)
+	// bs := f.dd.DecodeStringAsBytes()
 	// grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself.
 	fnerr := tm.UnmarshalJSON(f.d.nextValueBytes())
 	if fnerr != nil {
@@ -170,14 +188,14 @@ func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) {
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecBinaryUnmarshal(bm encoding.BinaryUnmarshaler) {
-	fnerr := bm.UnmarshalBinary(f.d.d.DecodeBytes(nil, false, true))
+	fnerr := bm.UnmarshalBinary(f.d.d.DecodeBytes(nil, true))
 	if fnerr != nil {
 		panic(fnerr)
 	}
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecRaw() []byte {
-	return f.d.raw()
+	return f.d.rawBytes()
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) TimeRtidIfBinc() uintptr {
@@ -197,7 +215,7 @@ func (f genHelperDecoder) HasExtensions() bool {
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecExt(v interface{}) (r bool) {
 	rt := reflect.TypeOf(v).Elem()
-	rtid := reflect.ValueOf(rt).Pointer()
+	rtid := rt2id(rt)
 	if xfFn := f.d.h.getExt(rtid); xfFn != nil {
 		f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
 		return true
@@ -205,15 +223,21 @@ func (f genHelperDecoder) DecExt(v interface{}) (r bool) {
 	return false 
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int, truncated bool) {
+func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int) {
 	return decInferLen(clen, maxlen, unit)
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) StringView(v []byte) string {
+	return stringView(v)
+}
+{{/*
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecSendContainerState(c containerState) {
 	if f.d.cr != nil {
 		f.d.cr.sendContainerState(c)
 	}
 }
+*/}}
 
 {{/*
 
diff --git a/vendor/github.com/ugorji/go/codec/gen.generated.go b/vendor/github.com/ugorji/go/codec/gen.generated.go
index 2ace97b78cd..b50a6024dde 100644
--- a/vendor/github.com/ugorji/go/codec/gen.generated.go
+++ b/vendor/github.com/ugorji/go/codec/gen.generated.go
@@ -10,21 +10,22 @@ const genDecMapTmpl = `
 {{var "l"}} := r.ReadMapStart()
 {{var "bh"}} := z.DecBasicHandle()
 if {{var "v"}} == nil {
-	{{var "rl"}}, _ := z.DecInferLen({{var "l"}}, {{var "bh"}}.MaxInitLen, {{ .Size }})
+	{{var "rl"}} := z.DecInferLen({{var "l"}}, {{var "bh"}}.MaxInitLen, {{ .Size }})
 	{{var "v"}} = make(map[{{ .KTyp }}]{{ .Typ }}, {{var "rl"}})
 	*{{ .Varname }} = {{var "v"}}
 }
 var {{var "mk"}} {{ .KTyp }}
 var {{var "mv"}} {{ .Typ }}
-var {{var "mg"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
+var {{var "mg"}}, {{var "mdn"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
 if {{var "bh"}}.MapValueReset {
 	{{if decElemKindPtr}}{{var "mg"}} = true
 	{{else if decElemKindIntf}}if !{{var "bh"}}.InterfaceReset { {{var "mg"}} = true }
 	{{else if not decElemKindImmutable}}{{var "mg"}} = true
 	{{end}} }
-if {{var "l"}} > 0  {
-for {{var "j"}} := 0; {{var "j"}} < {{var "l"}}; {{var "j"}}++ {
-	z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }})
+if {{var "l"}} != 0 {
+{{var "hl"}} := {{var "l"}} > 0 
+	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ {
+	r.ReadMapElemKey() {{/* z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) */}}
 	{{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }}
 {{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} {
 		{{var "mk"}} = string({{var "bv"}})
@@ -36,34 +37,17 @@ for {{var "j"}} := 0; {{var "j"}} < {{var "l"}}; {{var "j"}}++ {
 			{{var "ms"}} = false
 		} {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}}
 	} {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}}
-	z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }})
-	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }}
-	if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil {
-		{{var "v"}}[{{var "mk"}}] = {{var "mv"}}
-	}
-}
-} else if {{var "l"}} < 0  {
-for {{var "j"}} := 0; !r.CheckBreak(); {{var "j"}}++ {
-	z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }})
-	{{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }}
-{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} {
-		{{var "mk"}} = string({{var "bv"}})
-	}{{ end }}{{if decElemKindPtr}}
-	{{var "ms"}} = true {{ end }}
-	if {{var "mg"}} {
-		{{if decElemKindPtr}}{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{var "mk"}}] 
-		if {{var "mok"}} {
-			{{var "ms"}} = false
-		} {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}}
-	} {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}}
-	z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }})
-	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }}
-	if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil {
+	r.ReadMapElemValue() {{/* z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }}) */}}
+	{{var "mdn"}} = false
+	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ $y := printf "%vmdn%v" .TempVar .Rand }}{{ decLineVar $x $y }}
+	if {{var "mdn"}} {
+		if {{ var "bh" }}.DeleteOnNilMapValue { delete({{var "v"}}, {{var "mk"}}) } else { {{var "v"}}[{{var "mk"}}] = {{decElemZero}} }
+	} else if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil {
 		{{var "v"}}[{{var "mk"}}] = {{var "mv"}}
 	}
 }
 } // else len==0: TODO: Should we clear map entries?
-z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }})
+r.ReadMapEnd() {{/* z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }}) */}}
 `
 
 const genDecListTmpl = `
@@ -82,94 +66,67 @@ if {{var "l"}} == 0 {
 		{{var "v"}} = make({{ .CTyp }}, 0)
 		{{var "c"}} = true
 	} {{end}}
-} else if {{var "l"}} > 0 {
-	{{if isChan }}if {{var "v"}} == nil {
-		{{var "rl"}}, _ = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
-		{{var "v"}} = make({{ .CTyp }}, {{var "rl"}})
-		{{var "c"}} = true
-	}
-	for {{var "r"}} := 0; {{var "r"}} < {{var "l"}}; {{var "r"}}++ {
-		{{var "h"}}.ElemContainerState({{var "r"}})
-		var {{var "t"}} {{ .Typ }}
-		{{ $x := printf "%st%s" .TempVar .Rand }}{{ decLineVar $x }}
-		{{var "v"}} <- {{var "t"}}
-	}
-	{{ else }}	var {{var "rr"}}, {{var "rl"}} int {{/* // num2read, length of slice/array/chan */}}
-	var {{var "rt"}} bool {{/* truncated */}}
-	_, _ = {{var "rl"}}, {{var "rt"}}
-	{{var "rr"}} = {{var "l"}} // len({{var "v"}})
+} else {
+	{{var "hl"}} := {{var "l"}} > 0
+	var {{var "rl"}} int; _ =  {{var "rl"}}
+	{{if isSlice }} if {{var "hl"}} {
 	if {{var "l"}} > cap({{var "v"}}) {
-		{{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "l"}})
-		{{ else }}{{if not .Immutable }}
-		{{var "rg"}} := len({{var "v"}}) > 0
-		{{var "v2"}} := {{var "v"}} {{end}}
-		{{var "rl"}}, {{var "rt"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
-		if {{var "rt"}} {
-			if {{var "rl"}} <= cap({{var "v"}}) {
-				{{var "v"}} = {{var "v"}}[:{{var "rl"}}]
-			} else {
-				{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
-			}
+		{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+		if {{var "rl"}} <= cap({{var "v"}}) {
+			{{var "v"}} = {{var "v"}}[:{{var "rl"}}]
 		} else {
 			{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
 		}
 		{{var "c"}} = true
-		{{var "rr"}} = len({{var "v"}}) {{if not .Immutable }}
-			if {{var "rg"}} { copy({{var "v"}}, {{var "v2"}}) } {{end}} {{end}}{{/* end not Immutable, isArray */}}
-	} {{if isSlice }} else if {{var "l"}} != len({{var "v"}}) {
+	} else if {{var "l"}} != len({{var "v"}}) {
 		{{var "v"}} = {{var "v"}}[:{{var "l"}}]
 		{{var "c"}} = true
-	} {{end}}	{{/* end isSlice:47 */}} 
-	{{var "j"}} := 0
-	for ; {{var "j"}} < {{var "rr"}} ; {{var "j"}}++ {
-		{{var "h"}}.ElemContainerState({{var "j"}})
-		{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }}
 	}
-	{{if isArray }}for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ {
+	} {{end}}
+	var {{var "j"}} int 
+    // var {{var "dn"}} bool 
+	for ; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ {
+		{{if not isArray}} if {{var "j"}} == 0 && len({{var "v"}}) == 0 {
+			if {{var "hl"}} {
+				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+			} else {
+				{{var "rl"}} = 8
+			}
+			{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
+			{{var "c"}} = true 
+		}{{end}}
 		{{var "h"}}.ElemContainerState({{var "j"}})
-		z.DecSwallow()
-	}
-	{{ else }}if {{var "rt"}} {
-		for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ {
-			{{var "v"}} = append({{var "v"}}, {{ zero}})
-			{{var "h"}}.ElemContainerState({{var "j"}})
-			{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }}
-		}
-	} {{end}} {{/* end isArray:56 */}}
-	{{end}} {{/* end isChan:16 */}}
-} else { {{/* len < 0 */}}
-	{{var "j"}} := 0
-	for ; !r.CheckBreak(); {{var "j"}}++ {
-		{{if isChan }}
-		{{var "h"}}.ElemContainerState({{var "j"}})
-		var {{var "t"}} {{ .Typ }}
-		{{ $x := printf "%st%s" .TempVar .Rand }}{{ decLineVar $x }}
-		{{var "v"}} <- {{var "t"}} 
-		{{ else }}
+        // {{var "dn"}} = r.TryDecodeAsNil()
+        {{if isChan}}{{ $x := printf "%[1]vv%[2]v" .TempVar .Rand }}var {{var $x}} {{ .Typ }}
+		{{ decLineVar $x }}
+		{{var "v"}} <- {{ $x }}
+        {{else}}
+		// if indefinite, etc, then expand the slice if necessary
+		var {{var "db"}} bool
 		if {{var "j"}} >= len({{var "v"}}) {
-			{{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "j"}}+1)
-			{{ else }}{{var "v"}} = append({{var "v"}}, {{zero}})// var {{var "z"}} {{ .Typ }}
-			{{var "c"}} = true {{end}}
+			{{if isSlice }} {{var "v"}} = append({{var "v"}}, {{ zero }}); {{var "c"}} = true
+			{{else}} z.DecArrayCannotExpand(len(v), {{var "j"}}+1); {{var "db"}} = true
+			{{end}}
 		}
-		{{var "h"}}.ElemContainerState({{var "j"}})
-		if {{var "j"}} < len({{var "v"}}) {
-			{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }}
-		} else {
+		if {{var "db"}} {
 			z.DecSwallow()
+		} else {
+			{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }}
 		}
-		{{end}}
+        {{end}}
 	}
-	{{if isSlice }}if {{var "j"}} < len({{var "v"}}) {
+	{{if isSlice}} if {{var "j"}} < len({{var "v"}}) {
 		{{var "v"}} = {{var "v"}}[:{{var "j"}}]
 		{{var "c"}} = true
 	} else if {{var "j"}} == 0 && {{var "v"}} == nil {
-		{{var "v"}} = []{{ .Typ }}{}
+		{{var "v"}} = make([]{{ .Typ }}, 0)
 		{{var "c"}} = true
-	}{{end}}
+	} {{end}}
 }
 {{var "h"}}.End()
 {{if not isArray }}if {{var "c"}} { 
 	*{{ .Varname }} = {{var "v"}}
 }{{end}}
+
 `
 
diff --git a/vendor/github.com/ugorji/go/codec/gen.go b/vendor/github.com/ugorji/go/codec/gen.go
index c4944dbff3e..043f10d80dc 100644
--- a/vendor/github.com/ugorji/go/codec/gen.go
+++ b/vendor/github.com/ugorji/go/codec/gen.go
@@ -1,3 +1,5 @@
+// +build codecgen.exec
+
 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
@@ -80,6 +82,10 @@ import (
 // Note:
 //   It was a conscious decision to have gen.go always explicitly call EncodeNil or TryDecodeAsNil.
 //   This way, there isn't a function call overhead just to see that we should not enter a block of code.
+//
+// Note:
+//   codecgen-generated code depends on the variables defined by fast-path.generated.go.
+//   consequently, you cannot run with tags "codecgen notfastpath".
 
 // GenVersion is the current version of codecgen.
 //
@@ -94,7 +100,8 @@ import (
 //     changes in signature of some unpublished helper methods and codecgen cmdline arguments.
 // v4: Removed separator support from (en|de)cDriver, and refactored codec(gen)
 // v5: changes to support faster json decoding. Let encoder/decoder maintain state of collections.
-const GenVersion = 5
+// v6: removed unsafe from gen, and now uses codecgen.exec tag
+const genVersion = 8
 
 const (
 	genCodecPkg        = "codec1978"
@@ -126,7 +133,6 @@ var (
 	genExpectArrayOrMapErr = errors.New("unexpected type. Expecting array/map/slice")
 	genBase64enc           = base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789__")
 	genQNameRegex          = regexp.MustCompile(`[A-Za-z_.]+`)
-	genCheckVendor         bool
 )
 
 // genRunner holds some state used during a Gen run.
@@ -147,8 +153,7 @@ type genRunner struct {
 	is map[reflect.Type]struct{} // types seen during import search
 	bp string                    // base PkgPath, for which we are generating for
 
-	cpfx   string // codec package prefix
-	unsafe bool   // is unsafe to be used in generated code?
+	cpfx string // codec package prefix
 
 	tm map[reflect.Type]struct{} // types for which enc/dec must be generated
 	ts []reflect.Type            // types for which enc/dec must be generated
@@ -158,13 +163,16 @@ type genRunner struct {
 
 	ti *TypeInfos
 	// rr *rand.Rand // random generator for file-specific types
+
+	nx bool // no extensions
 }
 
 // Gen will write a complete go file containing Selfer implementations for each
 // type passed. All the types must be in the same package.
 //
-// Library users: *DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.*
-func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeInfos, typ ...reflect.Type) {
+// Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
+func Gen(w io.Writer, buildTags, pkgName, uid string, noExtensions bool,
+	ti *TypeInfos, typ ...reflect.Type) {
 	// All types passed to this method do not have a codec.Selfer method implemented directly.
 	// codecgen already checks the AST and skips any types that define the codec.Selfer methods.
 	// Consequently, there's no need to check and trim them if they implement codec.Selfer
@@ -173,19 +181,19 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
 		return
 	}
 	x := genRunner{
-		unsafe: useUnsafe,
-		w:      w,
-		t:      typ,
-		te:     make(map[uintptr]bool),
-		td:     make(map[uintptr]bool),
-		im:     make(map[string]reflect.Type),
-		imn:    make(map[string]string),
-		is:     make(map[reflect.Type]struct{}),
-		tm:     make(map[reflect.Type]struct{}),
-		ts:     []reflect.Type{},
-		bp:     genImportPath(typ[0]),
-		xs:     uid,
-		ti:     ti,
+		w:   w,
+		t:   typ,
+		te:  make(map[uintptr]bool),
+		td:  make(map[uintptr]bool),
+		im:  make(map[string]reflect.Type),
+		imn: make(map[string]string),
+		is:  make(map[reflect.Type]struct{}),
+		tm:  make(map[reflect.Type]struct{}),
+		ts:  []reflect.Type{},
+		bp:  genImportPath(typ[0]),
+		xs:  uid,
+		ti:  ti,
+		nx:  noExtensions,
 	}
 	if x.ti == nil {
 		x.ti = defTypeInfos
@@ -234,11 +242,8 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
 		x.linef("%s \"%s\"", x.imn[k], k)
 	}
 	// add required packages
-	for _, k := range [...]string{"reflect", "unsafe", "runtime", "fmt", "errors"} {
+	for _, k := range [...]string{"reflect", "runtime", "fmt", "errors"} {
 		if _, ok := x.im[k]; !ok {
-			if k == "unsafe" && !x.unsafe {
-				continue
-			}
 			x.line("\"" + k + "\"")
 		}
 	}
@@ -265,20 +270,16 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
 	x.line(")")
 	x.line("")
 
-	if x.unsafe {
-		x.line("type codecSelferUnsafeString" + x.xs + " struct { Data uintptr; Len int}")
-		x.line("")
-	}
 	x.hn = "codecSelfer" + x.xs
 	x.line("type " + x.hn + " struct{}")
 	x.line("")
 
 	x.varsfxreset()
 	x.line("func init() {")
-	x.linef("if %sGenVersion != %v {", x.cpfx, GenVersion)
+	x.linef("if %sGenVersion != %v {", x.cpfx, genVersion)
 	x.line("_, file, _, _ := runtime.Caller(0)")
 	x.line(`err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v", `)
-	x.linef(`%v, %sGenVersion, file)`, GenVersion, x.cpfx)
+	x.linef(`%v, %sGenVersion, file)`, genVersion, x.cpfx)
 	x.line("panic(err)")
 	x.linef("}")
 	x.line("if false { // reference the types, but skip this branch at build/run time")
@@ -289,10 +290,6 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
 		x.linef("var v%v %s.%s", n, x.imn[k], t.Name())
 		n++
 	}
-	if x.unsafe {
-		x.linef("var v%v unsafe.Pointer", n)
-		n++
-	}
 	if n > 0 {
 		x.out("_")
 		for i := 1; i < n; i++ {
@@ -315,7 +312,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
 	}
 
 	for _, t := range x.ts {
-		rtid := reflect.ValueOf(t).Pointer()
+		rtid := rt2id(t)
 		// generate enc functions for all these slice/map types.
 		x.varsfxreset()
 		x.linef("func (x %s) enc%s(v %s%s, e *%sEncoder) {", x.hn, x.genMethodNameT(t), x.arr2str(t, "*"), x.genTypeName(t), x.cpfx)
@@ -545,21 +542,21 @@ func (x *genRunner) selfer(encode bool) {
 		x.out(fnSigPfx)
 		x.line(") codecDecodeSelfFromMap(l int, d *" + x.cpfx + "Decoder) {")
 		x.genRequiredMethodVars(false)
-		x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, genStructMapStyleConsolidated)
+		x.decStructMap(genTopLevelVarName, "l", rt2id(t0), t0, genStructMapStyleConsolidated)
 		x.line("}")
 		x.line("")
 	} else {
 		x.out(fnSigPfx)
 		x.line(") codecDecodeSelfFromMapLenPrefix(l int, d *" + x.cpfx + "Decoder) {")
 		x.genRequiredMethodVars(false)
-		x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, genStructMapStyleLenPrefix)
+		x.decStructMap(genTopLevelVarName, "l", rt2id(t0), t0, genStructMapStyleLenPrefix)
 		x.line("}")
 		x.line("")
 
 		x.out(fnSigPfx)
 		x.line(") codecDecodeSelfFromMapCheckBreak(l int, d *" + x.cpfx + "Decoder) {")
 		x.genRequiredMethodVars(false)
-		x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, genStructMapStyleCheckBreak)
+		x.decStructMap(genTopLevelVarName, "l", rt2id(t0), t0, genStructMapStyleCheckBreak)
 		x.line("}")
 		x.line("")
 	}
@@ -568,7 +565,7 @@ func (x *genRunner) selfer(encode bool) {
 	x.out(fnSigPfx)
 	x.line(") codecDecodeSelfFromArray(l int, d *" + x.cpfx + "Decoder) {")
 	x.genRequiredMethodVars(false)
-	x.decStructArray(genTopLevelVarName, "l", "return", reflect.ValueOf(t0).Pointer(), t0)
+	x.decStructArray(genTopLevelVarName, "l", "return", rt2id(t0), t0)
 	x.line("}")
 	x.line("")
 
@@ -645,7 +642,7 @@ func (x *genRunner) encVar(varname string, t reflect.Type) {
 // enc will encode a variable (varname) of type t,
 // except t is of kind reflect.Struct or reflect.Array, wherein varname is of type ptrTo(T) (to prevent copying)
 func (x *genRunner) enc(varname string, t reflect.Type) {
-	rtid := reflect.ValueOf(t).Pointer()
+	rtid := rt2id(t)
 	// We call CodecEncodeSelf if one of the following are honored:
 	//   - the type already implements Selfer, call that
 	//   - the type has a Selfer implementation just created, use that
@@ -720,7 +717,7 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
 		x.linef("r.EncodeBuiltin(%s, %s)", vrtid, varname)
 	}
 	// only check for extensions if the type is named, and has a packagePath.
-	if genImportPath(t) != "" && t.Name() != "" {
+	if !x.nx && genImportPath(t) != "" && t.Name() != "" {
 		// first check if extensions are configued, before doing the interface conversion
 		x.linef("} else if z.HasExtensions() && z.EncExt(%s) {", varname)
 	}
@@ -780,7 +777,7 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
 			x.line("r.EncodeStringBytes(codecSelferC_RAW" + x.xs + ", []byte(" + varname + "))")
 		} else if fastpathAV.index(rtid) != -1 {
 			g := x.newGenV(t)
-			x.line("z.F." + g.MethodNamePfx("Enc", false) + "V(" + varname + ", false, e)")
+			x.line("z.F." + g.MethodNamePfx("Enc", false) + "V(" + varname + ", e)")
 		} else {
 			x.xtraSM(varname, true, t)
 			// x.encListFallback(varname, rtid, t)
@@ -794,7 +791,7 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
 		// x.line("if " + varname + " == nil { \nr.EncodeNil()\n } else { ")
 		if fastpathAV.index(rtid) != -1 {
 			g := x.newGenV(t)
-			x.line("z.F." + g.MethodNamePfx("Enc", false) + "V(" + varname + ", false, e)")
+			x.line("z.F." + g.MethodNamePfx("Enc", false) + "V(" + varname + ", e)")
 		} else {
 			x.xtraSM(varname, true, t)
 			// x.encMapFallback(varname, rtid, t)
@@ -852,55 +849,64 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 	// number of non-empty things we write out first.
 	// This is required as we need to pre-determine the size of the container,
 	// to support length-prefixing.
-	x.linef("var %s [%v]bool", numfieldsvar, len(tisfi))
-	x.linef("_, _, _ = %s, %s, %s", sepVarname, numfieldsvar, struct2arrvar)
+	if ti.anyOmitEmpty {
+		x.linef("var %s [%v]bool", numfieldsvar, len(tisfi))
+		x.linef("_ = %s", numfieldsvar)
+	}
+	x.linef("_, _ = %s, %s", sepVarname, struct2arrvar)
 	x.linef("const %s bool = %v", ti2arrayvar, ti.toArray)
-	nn := 0
-	for j, si := range tisfi {
-		if !si.omitEmpty {
-			nn++
-			continue
-		}
-		var t2 reflect.StructField
-		var omitline string
-		if si.i != -1 {
-			t2 = t.Field(int(si.i))
-		} else {
-			t2typ := t
-			varname3 := varname
-			for _, ix := range si.is {
-				for t2typ.Kind() == reflect.Ptr {
-					t2typ = t2typ.Elem()
-				}
-				t2 = t2typ.Field(ix)
-				t2typ = t2.Type
-				varname3 = varname3 + "." + t2.Name
-				if t2typ.Kind() == reflect.Ptr {
-					omitline += varname3 + " != nil && "
+	var nn int
+	if ti.anyOmitEmpty {
+		for j, si := range tisfi {
+			if !si.omitEmpty {
+				nn++
+				continue
+			}
+			var t2 reflect.StructField
+			var omitline string
+			{
+				t2typ := t
+				varname3 := varname
+				for ij, ix := range si.is {
+					if uint8(ij) == si.nis {
+						break
+					}
+					for t2typ.Kind() == reflect.Ptr {
+						t2typ = t2typ.Elem()
+					}
+					t2 = t2typ.Field(int(ix))
+					t2typ = t2.Type
+					varname3 = varname3 + "." + t2.Name
+					if t2typ.Kind() == reflect.Ptr {
+						omitline += varname3 + " != nil && "
+					}
 				}
 			}
+			// never check omitEmpty on a struct type, as it may contain uncomparable map/slice/etc.
+			// also, for maps/slices/arrays, check if len ! 0 (not if == zero value)
+			switch t2.Type.Kind() {
+			case reflect.Struct:
+				omitline += " true"
+			case reflect.Map, reflect.Slice, reflect.Array, reflect.Chan:
+				omitline += "len(" + varname + "." + t2.Name + ") != 0"
+			default:
+				omitline += varname + "." + t2.Name + " != " + x.genZeroValueR(t2.Type)
+			}
+			x.linef("%s[%v] = %s", numfieldsvar, j, omitline)
 		}
-		// never check omitEmpty on a struct type, as it may contain uncomparable map/slice/etc.
-		// also, for maps/slices/arrays, check if len ! 0 (not if == zero value)
-		switch t2.Type.Kind() {
-		case reflect.Struct:
-			omitline += " true"
-		case reflect.Map, reflect.Slice, reflect.Array, reflect.Chan:
-			omitline += "len(" + varname + "." + t2.Name + ") != 0"
-		default:
-			omitline += varname + "." + t2.Name + " != " + x.genZeroValueR(t2.Type)
-		}
-		x.linef("%s[%v] = %s", numfieldsvar, j, omitline)
 	}
-	x.linef("var %snn%s int", genTempVarPfx, i)
+	// x.linef("var %snn%s int", genTempVarPfx, i)
 	x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray {
-	x.line("r.EncodeArrayStart(" + strconv.FormatInt(int64(len(tisfi)), 10) + ")")
+	x.linef("r.WriteArrayStart(%d)", len(tisfi))
 	x.linef("} else {") // if not ti.toArray
-	x.linef("%snn%s = %v", genTempVarPfx, i, nn)
-	x.linef("for _, b := range %s { if b { %snn%s++ } }", numfieldsvar, genTempVarPfx, i)
-	x.linef("r.EncodeMapStart(%snn%s)", genTempVarPfx, i)
-	x.linef("%snn%s = %v", genTempVarPfx, i, 0)
-	// x.line("r.EncodeMapStart(" + strconv.FormatInt(int64(len(tisfi)), 10) + ")")
+	if ti.anyOmitEmpty {
+		x.linef("var %snn%s = %v", genTempVarPfx, i, nn)
+		x.linef("for _, b := range %s { if b { %snn%s++ } }", numfieldsvar, genTempVarPfx, i)
+		x.linef("r.WriteMapStart(%snn%s)", genTempVarPfx, i)
+		x.linef("%snn%s = %v", genTempVarPfx, i, 0)
+	} else {
+		x.linef("r.WriteMapStart(%d)", len(tisfi))
+	}
 	x.line("}") // close if not StructToArray
 
 	for j, si := range tisfi {
@@ -908,17 +914,18 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 		isNilVarName := genTempVarPfx + "n" + i
 		var labelUsed bool
 		var t2 reflect.StructField
-		if si.i != -1 {
-			t2 = t.Field(int(si.i))
-		} else {
+		{
 			t2typ := t
 			varname3 := varname
-			for _, ix := range si.is {
+			for ij, ix := range si.is {
+				if uint8(ij) == si.nis {
+					break
+				}
 				// fmt.Printf("%%%% %v, ix: %v\n", t2typ, ix)
 				for t2typ.Kind() == reflect.Ptr {
 					t2typ = t2typ.Elem()
 				}
-				t2 = t2typ.Field(ix)
+				t2 = t2typ.Field(int(ix))
 				t2typ = t2.Type
 				varname3 = varname3 + "." + t2.Name
 				if t2typ.Kind() == reflect.Ptr {
@@ -941,9 +948,10 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 
 		x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray
 		if labelUsed {
-			x.line("if " + isNilVarName + " { r.EncodeNil() } else { ")
+			x.linef("if %s { r.WriteArrayElem(); r.EncodeNil() } else { ", isNilVarName)
+			// x.linef("if %s { z.EncSendContainerState(codecSelfer_containerArrayElem%s); r.EncodeNil() } else { ", isNilVarName, x.xs)
 		}
-		x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
+		x.line("r.WriteArrayElem()") // x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
 		if si.omitEmpty {
 			x.linef("if %s[%v] {", numfieldsvar, j)
 		}
@@ -962,9 +970,9 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 		if si.omitEmpty {
 			x.linef("if %s[%v] {", numfieldsvar, j)
 		}
-		x.linef("z.EncSendContainerState(codecSelfer_containerMapKey%s)", x.xs)
+		x.line("r.WriteMapElemKey()") // x.linef("z.EncSendContainerState(codecSelfer_containerMapKey%s)", x.xs)
 		x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + ", string(\"" + si.encName + "\"))")
-		x.linef("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
+		x.line("r.WriteMapElemValue()") // x.linef("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
 		if labelUsed {
 			x.line("if " + isNilVarName + " { r.EncodeNil() } else { ")
 			x.encVar(varname+"."+t2.Name, t2.Type)
@@ -978,9 +986,9 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 		x.linef("} ") // end if/else ti.toArray
 	}
 	x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray {
-	x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
+	x.line("r.WriteArrayEnd()")                          // x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
 	x.line("} else {")
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
+	x.line("r.WriteMapEnd()") // x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
 	x.line("}")
 
 }
@@ -996,36 +1004,36 @@ func (x *genRunner) encListFallback(varname string, t reflect.Type) {
 	}
 	i := x.varsfx()
 	g := genTempVarPfx
-	x.line("r.EncodeArrayStart(len(" + varname + "))")
+	x.line("r.WriteArrayStart(len(" + varname + "))")
 	if t.Kind() == reflect.Chan {
 		x.linef("for %si%s, %si2%s := 0, len(%s); %si%s < %si2%s; %si%s++ {", g, i, g, i, varname, g, i, g, i, g, i)
-		x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
+		x.line("r.WriteArrayElem()") // x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
 		x.linef("%sv%s := <-%s", g, i, varname)
 	} else {
 		// x.linef("for %si%s, %sv%s := range %s {", genTempVarPfx, i, genTempVarPfx, i, varname)
 		x.linef("for _, %sv%s := range %s {", genTempVarPfx, i, varname)
-		x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
+		x.line("r.WriteArrayElem()") // x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
 	}
 	x.encVar(genTempVarPfx+"v"+i, t.Elem())
 	x.line("}")
-	x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
+	x.line("r.WriteArrayEnd()") // x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
 }
 
 func (x *genRunner) encMapFallback(varname string, t reflect.Type) {
 	// TODO: expand this to handle canonical.
 	i := x.varsfx()
-	x.line("r.EncodeMapStart(len(" + varname + "))")
+	x.line("r.WriteMapStart(len(" + varname + "))")
 	x.linef("for %sk%s, %sv%s := range %s {", genTempVarPfx, i, genTempVarPfx, i, varname)
 	// x.line("for " + genTempVarPfx + "k" + i + ", " + genTempVarPfx + "v" + i + " := range " + varname + " {")
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapKey%s)", x.xs)
+	x.line("r.WriteMapElemKey()") // f("z.EncSendContainerState(codecSelfer_containerMapKey%s)", x.xs)
 	x.encVar(genTempVarPfx+"k"+i, t.Key())
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
+	x.line("r.WriteMapElemValue()") // f("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
 	x.encVar(genTempVarPfx+"v"+i, t.Elem())
 	x.line("}")
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
+	x.line("r.WriteMapEnd()") // f("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
 }
 
-func (x *genRunner) decVar(varname string, t reflect.Type, canBeNil bool) {
+func (x *genRunner) decVar(varname, decodedNilVarname string, t reflect.Type, canBeNil bool) {
 	// We only encode as nil if a nillable value.
 	// This removes some of the wasted checks for TryDecodeAsNil.
 	// We need to think about this more, to see what happens if omitempty, etc
@@ -1038,7 +1046,9 @@ func (x *genRunner) decVar(varname string, t reflect.Type, canBeNil bool) {
 	}
 	if canBeNil {
 		x.line("if r.TryDecodeAsNil() {")
-		if t.Kind() == reflect.Ptr {
+		if decodedNilVarname != "" {
+			x.line(decodedNilVarname + " = true")
+		} else if t.Kind() == reflect.Ptr {
 			x.line("if " + varname + " != nil { ")
 
 			// if varname is a field of a struct (has a dot in it),
@@ -1098,7 +1108,7 @@ func (x *genRunner) dec(varname string, t reflect.Type) {
 	// assumptions:
 	//   - the varname is to a pointer already. No need to take address of it
 	//   - t is always a baseType T (not a *T, etc).
-	rtid := reflect.ValueOf(t).Pointer()
+	rtid := rt2id(t)
 	tptr := reflect.PtrTo(t)
 	if x.checkForSelfer(t, varname) {
 		if t.Implements(selferTyp) || tptr.Implements(selferTyp) {
@@ -1156,7 +1166,7 @@ func (x *genRunner) dec(varname string, t reflect.Type) {
 		x.linef("r.DecodeBuiltin(%s, %s)", vrtid, varname)
 	}
 	// only check for extensions if the type is named, and has a packagePath.
-	if genImportPath(t) != "" && t.Name() != "" {
+	if !x.nx && genImportPath(t) != "" && t.Name() != "" {
 		// first check if extensions are configued, before doing the interface conversion
 		x.linef("} else if z.HasExtensions() && z.DecExt(%s) {", varname)
 	}
@@ -1231,10 +1241,10 @@ func (x *genRunner) dec(varname string, t reflect.Type) {
 		// - if elements are primitives or Selfers, call dedicated function on each member.
 		// - else call Encoder.encode(XXX) on it.
 		if rtid == uint8SliceTypId {
-			x.line("*" + varname + " = r.DecodeBytes(*(*[]byte)(" + varname + "), false, false)")
+			x.line("*" + varname + " = r.DecodeBytes(*(*[]byte)(" + varname + "), false)")
 		} else if fastpathAV.index(rtid) != -1 {
 			g := x.newGenV(t)
-			x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", false, d)")
+			x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", d)")
 		} else {
 			x.xtraSM(varname, false, t)
 			// x.decListFallback(varname, rtid, false, t)
@@ -1246,7 +1256,7 @@ func (x *genRunner) dec(varname string, t reflect.Type) {
 		// - else call Encoder.encode(XXX) on it.
 		if fastpathAV.index(rtid) != -1 {
 			g := x.newGenV(t)
-			x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", false, d)")
+			x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", d)")
 		} else {
 			x.xtraSM(varname, false, t)
 			// x.decMapFallback(varname, rtid, t)
@@ -1318,11 +1328,11 @@ func (x *genRunner) decTryAssignPrimitive(varname string, t reflect.Type) (tryAs
 
 func (x *genRunner) decListFallback(varname string, rtid uintptr, t reflect.Type) {
 	if t.AssignableTo(uint8SliceTyp) {
-		x.line("*" + varname + " = r.DecodeBytes(*((*[]byte)(" + varname + ")), false, false)")
+		x.line("*" + varname + " = r.DecodeBytes(*((*[]byte)(" + varname + ")), false)")
 		return
 	}
 	if t.Kind() == reflect.Array && t.Elem().Kind() == reflect.Uint8 {
-		x.linef("r.DecodeBytes( ((*[%s]byte)(%s))[:], false, true)", t.Len(), varname)
+		x.linef("r.DecodeBytes( ((*[%s]byte)(%s))[:], true)", t.Len(), varname)
 		return
 	}
 	type tstruc struct {
@@ -1340,13 +1350,13 @@ func (x *genRunner) decListFallback(varname string, rtid uintptr, t reflect.Type
 	funcs := make(template.FuncMap)
 
 	funcs["decLineVar"] = func(varname string) string {
-		x.decVar(varname, telem, false)
-		return ""
-	}
-	funcs["decLine"] = func(pfx string) string {
-		x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(telem), false)
+		x.decVar(varname, "", telem, false)
 		return ""
 	}
+	// funcs["decLine"] = func(pfx string) string {
+	// 	x.decVar(ts.TempVar+pfx+ts.Rand, "", reflect.PtrTo(telem), false)
+	// 	return ""
+	// }
 	funcs["var"] = func(s string) string {
 		return ts.TempVar + s + ts.Rand
 	}
@@ -1402,21 +1412,21 @@ func (x *genRunner) decMapFallback(varname string, rtid uintptr, t reflect.Type)
 		return telem.Kind() == reflect.Interface
 	}
 	funcs["decLineVarK"] = func(varname string) string {
-		x.decVar(varname, tkey, false)
+		x.decVar(varname, "", tkey, false)
 		return ""
 	}
-	funcs["decLineVar"] = func(varname string) string {
-		x.decVar(varname, telem, false)
-		return ""
-	}
-	funcs["decLineK"] = func(pfx string) string {
-		x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(tkey), false)
-		return ""
-	}
-	funcs["decLine"] = func(pfx string) string {
-		x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(telem), false)
+	funcs["decLineVar"] = func(varname, decodedNilVarname string) string {
+		x.decVar(varname, decodedNilVarname, telem, false)
 		return ""
 	}
+	// funcs["decLineK"] = func(pfx string) string {
+	// 	x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(tkey), false)
+	// 	return ""
+	// }
+	// funcs["decLine"] = func(pfx string) string {
+	// 	x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(telem), false)
+	// 	return ""
+	// }
 	funcs["var"] = func(s string) string {
 		return ts.TempVar + s + ts.Rand
 	}
@@ -1437,18 +1447,19 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt
 	for _, si := range tisfi {
 		x.line("case \"" + si.encName + "\":")
 		var t2 reflect.StructField
-		if si.i != -1 {
-			t2 = t.Field(int(si.i))
-		} else {
+		{
 			//we must accommodate anonymous fields, where the embedded field is a nil pointer in the value.
 			// t2 = t.FieldByIndex(si.is)
 			t2typ := t
 			varname3 := varname
-			for _, ix := range si.is {
+			for ij, ix := range si.is {
+				if uint8(ij) == si.nis {
+					break
+				}
 				for t2typ.Kind() == reflect.Ptr {
 					t2typ = t2typ.Elem()
 				}
-				t2 = t2typ.Field(ix)
+				t2 = t2typ.Field(int(ix))
 				t2typ = t2.Type
 				varname3 = varname3 + "." + t2.Name
 				if t2typ.Kind() == reflect.Ptr {
@@ -1456,7 +1467,7 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt
 				}
 			}
 		}
-		x.decVar(varname+"."+t2.Name, t2.Type, false)
+		x.decVar(varname+"."+t2.Name, "", t2.Type, false)
 	}
 	x.line("default:")
 	// pass the slice here, so that the string will not escape, and maybe save allocation
@@ -1469,17 +1480,6 @@ func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t ref
 	i := x.varsfx()
 	kName := tpfx + "s" + i
 
-	// We thought to use ReadStringAsBytes, as go compiler might optimize the copy out.
-	// However, using that was more expensive, as it seems that the switch expression
-	// is evaluated each time.
-	//
-	// We could depend on decodeString using a temporary/shared buffer internally.
-	// However, this model of creating a byte array, and using explicitly is faster,
-	// and allows optional use of unsafe []byte->string conversion without alloc.
-
-	// Also, ensure that the slice array doesn't escape.
-	// That will help escape analysis prevent allocation when it gets better.
-
 	// x.line("var " + kName + "Arr = [32]byte{} // default string to decode into")
 	// x.line("var " + kName + "Slc = " + kName + "Arr[:] // default slice to decode into")
 	// use the scratch buffer to avoid allocation (most field names are < 32).
@@ -1498,21 +1498,15 @@ func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t ref
 		x.linef("if %shl%s { if %sj%s >= %s { break }", tpfx, i, tpfx, i, lenvarname)
 		x.line("} else { if r.CheckBreak() { break }; }")
 	}
-	x.linef("z.DecSendContainerState(codecSelfer_containerMapKey%s)", x.xs)
-	x.line(kName + "Slc = r.DecodeBytes(" + kName + "Slc, true, true)")
+	x.line("r.ReadMapElemKey()") // f("z.DecSendContainerState(codecSelfer_containerMapKey%s)", x.xs)
+	x.line(kName + "Slc = r.DecodeStringAsBytes()")
 	// let string be scoped to this loop alone, so it doesn't escape.
-	if x.unsafe {
-		x.line(kName + "SlcHdr := codecSelferUnsafeString" + x.xs + "{uintptr(unsafe.Pointer(&" +
-			kName + "Slc[0])), len(" + kName + "Slc)}")
-		x.line(kName + " := *(*string)(unsafe.Pointer(&" + kName + "SlcHdr))")
-	} else {
-		x.line(kName + " := string(" + kName + "Slc)")
-	}
-	x.linef("z.DecSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
+	x.line(kName + " := string(" + kName + "Slc)")
+	x.line("r.ReadMapElemValue()") // f("z.DecSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
 	x.decStructMapSwitch(kName, varname, rtid, t)
 
 	x.line("} // end for " + tpfx + "j" + i)
-	x.linef("z.DecSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
+	x.line("r.ReadMapEnd()") // f("z.DecSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
 }
 
 func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid uintptr, t reflect.Type) {
@@ -1525,18 +1519,19 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 	x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length
 	for _, si := range tisfi {
 		var t2 reflect.StructField
-		if si.i != -1 {
-			t2 = t.Field(int(si.i))
-		} else {
+		{
 			//we must accommodate anonymous fields, where the embedded field is a nil pointer in the value.
 			// t2 = t.FieldByIndex(si.is)
 			t2typ := t
 			varname3 := varname
-			for _, ix := range si.is {
+			for ij, ix := range si.is {
+				if uint8(ij) == si.nis {
+					break
+				}
 				for t2typ.Kind() == reflect.Ptr {
 					t2typ = t2typ.Elem()
 				}
-				t2 = t2typ.Field(ix)
+				t2 = t2typ.Field(int(ix))
 				t2typ = t2.Type
 				varname3 = varname3 + "." + t2.Name
 				if t2typ.Kind() == reflect.Ptr {
@@ -1548,10 +1543,10 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 		x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = r.CheckBreak() }",
 			tpfx, i, tpfx, i, tpfx, i,
 			tpfx, i, lenvarname, tpfx, i)
-		x.linef("if %sb%s { z.DecSendContainerState(codecSelfer_containerArrayEnd%s); %s }",
-			tpfx, i, x.xs, breakString)
-		x.linef("z.DecSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
-		x.decVar(varname+"."+t2.Name, t2.Type, true)
+		x.linef("if %sb%s { r.ReadArrayEnd(); %s }", tpfx, i, breakString)
+		// x.linef("if %sb%s { z.DecSendContainerState(codecSelfer_containerArrayEnd%s); %s }", tpfx, i, x.xs, breakString)
+		x.line("r.ReadArrayElem()") // f("z.DecSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
+		x.decVar(varname+"."+t2.Name, "", t2.Type, true)
 	}
 	// read remaining values and throw away.
 	x.line("for {")
@@ -1559,10 +1554,10 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 		tpfx, i, tpfx, i, tpfx, i,
 		tpfx, i, lenvarname, tpfx, i)
 	x.linef("if %sb%s { break }", tpfx, i)
-	x.linef("z.DecSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
+	x.line("r.ReadArrayElem()") // f("z.DecSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
 	x.linef(`z.DecStructFieldNotFound(%sj%s - 1, "")`, tpfx, i)
 	x.line("}")
-	x.linef("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
+	x.line("r.ReadArrayEnd()") // f("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
 }
 
 func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) {
@@ -1572,7 +1567,7 @@ func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) {
 	x.linef("if %sct%s == codecSelferValueTypeMap%s {", genTempVarPfx, i, x.xs)
 	x.line(genTempVarPfx + "l" + i + " := r.ReadMapStart()")
 	x.linef("if %sl%s == 0 {", genTempVarPfx, i)
-	x.linef("z.DecSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
+	x.line("r.ReadMapEnd()") // f("z.DecSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
 	if genUseOneFunctionForDecStructMap {
 		x.line("} else { ")
 		x.linef("x.codecDecodeSelfFromMap(%sl%s, d)", genTempVarPfx, i)
@@ -1588,7 +1583,7 @@ func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) {
 	x.linef("} else if %sct%s == codecSelferValueTypeArray%s {", genTempVarPfx, i, x.xs)
 	x.line(genTempVarPfx + "l" + i + " := r.ReadArrayStart()")
 	x.linef("if %sl%s == 0 {", genTempVarPfx, i)
-	x.linef("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
+	x.line("r.ReadArrayEnd()") // f("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
 	x.line("} else { ")
 	x.linef("x.codecDecodeSelfFromArray(%sl%s, d)", genTempVarPfx, i)
 	x.line("}")
@@ -1653,15 +1648,8 @@ func (x *genV) MethodNamePfx(prefix string, prim bool) string {
 func genImportPath(t reflect.Type) (s string) {
 	s = t.PkgPath()
 	if genCheckVendor {
-		// HACK: Misbehaviour occurs in go 1.5. May have to re-visit this later.
-		// if s contains /vendor/ OR startsWith vendor/, then return everything after it.
-		const vendorStart = "vendor/"
-		const vendorInline = "/vendor/"
-		if i := strings.LastIndex(s, vendorInline); i >= 0 {
-			s = s[i+len(vendorInline):]
-		} else if strings.HasPrefix(s, vendorStart) {
-			s = s[len(vendorStart):]
-		}
+		// HACK: always handle vendoring. It should be typically on in go 1.6, 1.7
+		s = stripVendor(s)
 	}
 	return
 }
@@ -1783,8 +1771,8 @@ func genIsImmutable(t reflect.Type) (v bool) {
 }
 
 type genInternal struct {
-	Values []genV
-	Unsafe bool
+	Version int
+	Values  []genV
 }
 
 func (x genInternal) FastpathLen() (l int) {
@@ -1884,8 +1872,21 @@ func genInternalSortType(s string, elem bool) string {
 	panic("sorttype: unexpected type: " + s)
 }
 
+func stripVendor(s string) string {
+	// HACK: Misbehaviour occurs in go 1.5. May have to re-visit this later.
+	// if s contains /vendor/ OR startsWith vendor/, then return everything after it.
+	const vendorStart = "vendor/"
+	const vendorInline = "/vendor/"
+	if i := strings.LastIndex(s, vendorInline); i >= 0 {
+		s = s[i+len(vendorInline):]
+	} else if strings.HasPrefix(s, vendorStart) {
+		s = s[len(vendorStart):]
+	}
+	return s
+}
+
 // var genInternalMu sync.Mutex
-var genInternalV genInternal
+var genInternalV = genInternal{Version: genVersion}
 var genInternalTmplFuncs template.FuncMap
 var genInternalOnce sync.Once
 
@@ -1948,7 +1949,7 @@ func genInternalInit() {
 		"float64":     8,
 		"bool":        1,
 	}
-	var gt genInternal
+	var gt = genInternal{Version: genVersion}
 
 	// For each slice or map type, there must be a (symmetrical) Encode and Decode fast-path function
 	for _, s := range types {
@@ -1980,11 +1981,10 @@ func genInternalInit() {
 // It is run by the program author alone.
 // Unfortunately, it has to be exported so that it can be called from a command line tool.
 // *** DO NOT USE ***
-func genInternalGoFile(r io.Reader, w io.Writer, safe bool) (err error) {
+func genInternalGoFile(r io.Reader, w io.Writer) (err error) {
 	genInternalOnce.Do(genInternalInit)
 
 	gt := genInternalV
-	gt.Unsafe = !safe
 
 	t := template.New("").Funcs(genInternalTmplFuncs)
 
diff --git a/vendor/github.com/ugorji/go/codec/decode_go.go b/vendor/github.com/ugorji/go/codec/goversion_arrayof_gte_go15.go
similarity index 59%
rename from vendor/github.com/ugorji/go/codec/decode_go.go
rename to vendor/github.com/ugorji/go/codec/goversion_arrayof_gte_go15.go
index ba289cef613..7567e2c07b4 100644
--- a/vendor/github.com/ugorji/go/codec/decode_go.go
+++ b/vendor/github.com/ugorji/go/codec/goversion_arrayof_gte_go15.go
@@ -9,8 +9,6 @@ import "reflect"
 
 const reflectArrayOfSupported = true
 
-func reflectArrayOf(rvn reflect.Value) (rvn2 reflect.Value) {
-	rvn2 = reflect.New(reflect.ArrayOf(rvn.Len(), intfTyp)).Elem()
-	reflect.Copy(rvn2, rvn)
-	return
+func reflectArrayOf(count int, elem reflect.Type) reflect.Type {
+	return reflect.ArrayOf(count, elem)
 }
diff --git a/vendor/github.com/ugorji/go/codec/decode_go14.go b/vendor/github.com/ugorji/go/codec/goversion_arrayof_lt_go15.go
similarity index 64%
rename from vendor/github.com/ugorji/go/codec/decode_go14.go
rename to vendor/github.com/ugorji/go/codec/goversion_arrayof_lt_go15.go
index 50063bc8fc8..ec94bd0c0af 100644
--- a/vendor/github.com/ugorji/go/codec/decode_go14.go
+++ b/vendor/github.com/ugorji/go/codec/goversion_arrayof_lt_go15.go
@@ -9,6 +9,6 @@ import "reflect"
 
 const reflectArrayOfSupported = false
 
-func reflectArrayOf(rvn reflect.Value) (rvn2 reflect.Value) {
-	panic("reflect.ArrayOf unsupported")
+func reflectArrayOf(count int, elem reflect.Type) reflect.Type {
+	panic("codec: reflect.ArrayOf unsupported in this go version")
 }
diff --git a/vendor/github.com/ugorji/go/codec/goversion_makemap_gte_go19.go b/vendor/github.com/ugorji/go/codec/goversion_makemap_gte_go19.go
new file mode 100644
index 00000000000..51fe40e5bf2
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_makemap_gte_go19.go
@@ -0,0 +1,15 @@
+// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// +build go1.9
+
+package codec
+
+import "reflect"
+
+func makeMapReflect(t reflect.Type, size int) reflect.Value {
+	if size < 0 {
+		return reflect.MakeMapWithSize(t, 4)
+	}
+	return reflect.MakeMapWithSize(t, size)
+}
diff --git a/vendor/github.com/ugorji/go/codec/goversion_makemap_lt_go19.go b/vendor/github.com/ugorji/go/codec/goversion_makemap_lt_go19.go
new file mode 100644
index 00000000000..d4b9c2c8d9a
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_makemap_lt_go19.go
@@ -0,0 +1,12 @@
+// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// +build !go1.9
+
+package codec
+
+import "reflect"
+
+func makeMapReflect(t reflect.Type, size int) reflect.Value {
+	return reflect.MakeMap(t)
+}
diff --git a/vendor/github.com/ugorji/go/codec/goversion_unsupported_lt_go14.go b/vendor/github.com/ugorji/go/codec/goversion_unsupported_lt_go14.go
new file mode 100644
index 00000000000..dcd8c3d11ce
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_unsupported_lt_go14.go
@@ -0,0 +1,17 @@
+// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// +build !go1.4
+
+package codec
+
+// This codec package will only work for go1.4 and above.
+// This is for the following reasons:
+//   - go 1.4 was released in 2014
+//   - go runtime is written fully in go
+//   - interface only holds pointers
+//   - reflect.Value is stabilized as 3 words
+
+func init() {
+	panic("codec: go 1.3 and below are not supported")
+}
diff --git a/vendor/github.com/ugorji/go/codec/gen_15.go b/vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go15.go
similarity index 72%
rename from vendor/github.com/ugorji/go/codec/gen_15.go
rename to vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go15.go
index ab76c310270..68626e1ce74 100644
--- a/vendor/github.com/ugorji/go/codec/gen_15.go
+++ b/vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go15.go
@@ -7,6 +7,4 @@ package codec
 
 import "os"
 
-func init() {
-	genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") == "1"
-}
+var genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") == "1"
diff --git a/vendor/github.com/ugorji/go/codec/gen_16.go b/vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go16.go
similarity index 65%
rename from vendor/github.com/ugorji/go/codec/gen_16.go
rename to vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go16.go
index 87c04e2e182..344f5967bee 100644
--- a/vendor/github.com/ugorji/go/codec/gen_16.go
+++ b/vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go16.go
@@ -1,12 +1,10 @@
 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
-// +build go1.6
+// +build go1.6,!go1.7
 
 package codec
 
 import "os"
 
-func init() {
-	genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") != "0"
-}
+var genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") != "0"
diff --git a/vendor/github.com/ugorji/go/codec/gen_17.go b/vendor/github.com/ugorji/go/codec/goversion_vendor_gte_go17.go
similarity index 82%
rename from vendor/github.com/ugorji/go/codec/gen_17.go
rename to vendor/github.com/ugorji/go/codec/goversion_vendor_gte_go17.go
index 3881a43ce68..de91d29407f 100644
--- a/vendor/github.com/ugorji/go/codec/gen_17.go
+++ b/vendor/github.com/ugorji/go/codec/goversion_vendor_gte_go17.go
@@ -5,6 +5,4 @@
 
 package codec
 
-func init() {
-	genCheckVendor = true
-}
+const genCheckVendor = true
diff --git a/vendor/github.com/ugorji/go/codec/goversion_vendor_lt_go15.go b/vendor/github.com/ugorji/go/codec/goversion_vendor_lt_go15.go
new file mode 100644
index 00000000000..9d007bfed4c
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_vendor_lt_go15.go
@@ -0,0 +1,8 @@
+// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// +build !go1.5
+
+package codec
+
+var genCheckVendor = false
diff --git a/vendor/github.com/ugorji/go/codec/helper.go b/vendor/github.com/ugorji/go/codec/helper.go
index 8b94fc1e4db..b846df0d884 100644
--- a/vendor/github.com/ugorji/go/codec/helper.go
+++ b/vendor/github.com/ugorji/go/codec/helper.go
@@ -103,8 +103,10 @@ import (
 	"errors"
 	"fmt"
 	"math"
+	"os"
 	"reflect"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -112,32 +114,56 @@ import (
 
 const (
 	scratchByteArrayLen = 32
-	initCollectionCap   = 32 // 32 is defensive. 16 is preferred.
+	// initCollectionCap   = 16 // 32 is defensive. 16 is preferred.
 
 	// Support encoding.(Binary|Text)(Unm|M)arshaler.
 	// This constant flag will enable or disable it.
 	supportMarshalInterfaces = true
 
-	// Each Encoder or Decoder uses a cache of functions based on conditionals,
-	// so that the conditionals are not run every time.
-	//
-	// Either a map or a slice is used to keep track of the functions.
-	// The map is more natural, but has a higher cost than a slice/array.
-	// This flag (useMapForCodecCache) controls which is used.
-	//
-	// From benchmarks, slices with linear search perform better with < 32 entries.
-	// We have typically seen a high threshold of about 24 entries.
-	useMapForCodecCache = false
-
 	// for debugging, set this to false, to catch panic traces.
 	// Note that this will always cause rpc tests to fail, since they need io.EOF sent via panic.
 	recoverPanicToErr = true
 
-	// if resetSliceElemToZeroValue, then on decoding a slice, reset the element to a zero value first.
-	// Only concern is that, if the slice already contained some garbage, we will decode into that garbage.
-	// The chances of this are slim, so leave this "optimization".
-	// TODO: should this be true, to ensure that we always decode into a "zero" "empty" value?
-	resetSliceElemToZeroValue bool = false
+	// arrayCacheLen is the length of the cache used in encoder or decoder for
+	// allowing zero-alloc initialization.
+	arrayCacheLen = 8
+
+	// We tried an optimization, where we detect if a type is one of the known types
+	// we optimized for (e.g. int, []uint64, etc).
+	//
+	// However, we notice some worse performance when using this optimization.
+	// So we hide it behind a flag, to turn on if needed.
+	useLookupRecognizedTypes = false
+
+	// using recognized allows us to do d.decode(interface{}) instead of d.decodeValue(reflect.Value)
+	// when we can infer that the kind of the interface{} is one of the ones hard-coded in the
+	// type switch for known types or the ones defined by fast-path.
+	//
+	// However, it seems we get better performance when we don't recognize, and just let
+	// reflection handle it.
+	//
+	// Reasoning is as below:
+	// typeswitch is a binary search with a branch to a code-point.
+	// getdecfn is a binary search with a call to a function pointer.
+	//
+	// both are about the same.
+	//
+	// so: why prefer typeswitch?
+	//
+	// is recognized does the following:
+	// - lookup rtid
+	// - check if in sorted list
+	// - calls decode(type switch)
+	//   - 1 or 2 binary search to a point in code
+	//   - branch there
+	//
+	// vs getdecfn
+	// - lookup rtid
+	// - check in sorted list for a function pointer
+	// - calls it to decode using reflection (optimized)
+
+	// always set xDebug = false before releasing software
+	xDebug = true
 )
 
 var (
@@ -145,6 +171,20 @@ var (
 	zeroByteSlice = oneByteArr[:0:0]
 )
 
+var pool pooler
+
+func init() {
+	pool.init()
+}
+
+// type findCodecFnMode uint8
+
+// const (
+// 	findCodecFnModeMap findCodecFnMode = iota
+// 	findCodecFnModeBinarySearch
+// 	findCodecFnModeLinearSearch
+// )
+
 type charEncoding uint8
 
 const (
@@ -177,6 +217,36 @@ const (
 	// valueTypeInvalid = 0xff
 )
 
+func (x valueType) String() string {
+	switch x {
+	case valueTypeNil:
+		return "Nil"
+	case valueTypeInt:
+		return "Int"
+	case valueTypeUint:
+		return "Uint"
+	case valueTypeFloat:
+		return "Float"
+	case valueTypeBool:
+		return "Bool"
+	case valueTypeString:
+		return "String"
+	case valueTypeSymbol:
+		return "Symbol"
+	case valueTypeBytes:
+		return "Bytes"
+	case valueTypeMap:
+		return "Map"
+	case valueTypeArray:
+		return "Array"
+	case valueTypeTimestamp:
+		return "Timestamp"
+	case valueTypeExt:
+		return "Ext"
+	}
+	return strconv.FormatInt(int64(x), 10)
+}
+
 type seqType uint8
 
 const (
@@ -216,30 +286,26 @@ const rgetMaxRecursion = 2
 
 // Anecdotally, we believe most types have <= 12 fields.
 // Java's PMD rules set TooManyFields threshold to 15.
-const rgetPoolTArrayLen = 12
+const typeInfoLoadArrayLen = 12
 
-type rgetT struct {
+type typeInfoLoad struct {
 	fNames   []string
 	encNames []string
 	etypes   []uintptr
 	sfis     []*structFieldInfo
 }
 
-type rgetPoolT struct {
-	fNames   [rgetPoolTArrayLen]string
-	encNames [rgetPoolTArrayLen]string
-	etypes   [rgetPoolTArrayLen]uintptr
-	sfis     [rgetPoolTArrayLen]*structFieldInfo
-	sfiidx   [rgetPoolTArrayLen]sfiIdx
+type typeInfoLoadArray struct {
+	fNames   [typeInfoLoadArrayLen]string
+	encNames [typeInfoLoadArrayLen]string
+	etypes   [typeInfoLoadArrayLen]uintptr
+	sfis     [typeInfoLoadArrayLen]*structFieldInfo
+	sfiidx   [typeInfoLoadArrayLen]sfiIdx
 }
 
-var rgetPool = sync.Pool{
-	New: func() interface{} { return new(rgetPoolT) },
-}
-
-type containerStateRecv interface {
-	sendContainerState(containerState)
-}
+// type containerStateRecv interface {
+// 	sendContainerState(containerState)
+// }
 
 // mirror json.Marshaler and json.Unmarshaler here,
 // so we don't import the encoding/json package
@@ -250,6 +316,8 @@ type jsonUnmarshaler interface {
 	UnmarshalJSON([]byte) error
 }
 
+// type byteAccepter func(byte) bool
+
 var (
 	bigen               = binary.BigEndian
 	structInfoFieldName = "_struct"
@@ -278,17 +346,17 @@ var (
 
 	selferTyp = reflect.TypeOf((*Selfer)(nil)).Elem()
 
-	uint8SliceTypId = reflect.ValueOf(uint8SliceTyp).Pointer()
-	rawExtTypId     = reflect.ValueOf(rawExtTyp).Pointer()
-	rawTypId        = reflect.ValueOf(rawTyp).Pointer()
-	intfTypId       = reflect.ValueOf(intfTyp).Pointer()
-	timeTypId       = reflect.ValueOf(timeTyp).Pointer()
-	stringTypId     = reflect.ValueOf(stringTyp).Pointer()
+	uint8SliceTypId = rt2id(uint8SliceTyp)
+	rawExtTypId     = rt2id(rawExtTyp)
+	rawTypId        = rt2id(rawTyp)
+	intfTypId       = rt2id(intfTyp)
+	timeTypId       = rt2id(timeTyp)
+	stringTypId     = rt2id(stringTyp)
 
-	mapStrIntfTypId  = reflect.ValueOf(mapStrIntfTyp).Pointer()
-	mapIntfIntfTypId = reflect.ValueOf(mapIntfIntfTyp).Pointer()
-	intfSliceTypId   = reflect.ValueOf(intfSliceTyp).Pointer()
-	// mapBySliceTypId  = reflect.ValueOf(mapBySliceTyp).Pointer()
+	mapStrIntfTypId  = rt2id(mapStrIntfTyp)
+	mapIntfIntfTypId = rt2id(mapIntfIntfTyp)
+	intfSliceTypId   = rt2id(intfSliceTyp)
+	// mapBySliceTypId  = rt2id(mapBySliceTyp)
 
 	intBitsize  uint8 = uint8(reflect.TypeOf(int(0)).Bits())
 	uintBitsize uint8 = uint8(reflect.TypeOf(uint(0)).Bits())
@@ -303,6 +371,99 @@ var (
 
 var defTypeInfos = NewTypeInfos([]string{"codec", "json"})
 
+var immutableKindsSet = [32]bool{
+	// reflect.Invalid:  ,
+	reflect.Bool:       true,
+	reflect.Int:        true,
+	reflect.Int8:       true,
+	reflect.Int16:      true,
+	reflect.Int32:      true,
+	reflect.Int64:      true,
+	reflect.Uint:       true,
+	reflect.Uint8:      true,
+	reflect.Uint16:     true,
+	reflect.Uint32:     true,
+	reflect.Uint64:     true,
+	reflect.Uintptr:    true,
+	reflect.Float32:    true,
+	reflect.Float64:    true,
+	reflect.Complex64:  true,
+	reflect.Complex128: true,
+	// reflect.Array
+	// reflect.Chan
+	// reflect.Func: true,
+	// reflect.Interface
+	// reflect.Map
+	// reflect.Ptr
+	// reflect.Slice
+	reflect.String: true,
+	// reflect.Struct
+	// reflect.UnsafePointer
+}
+
+var recognizedRtids []uintptr
+var recognizedRtidPtrs []uintptr
+var recognizedRtidOrPtrs []uintptr
+
+func init() {
+	if !useLookupRecognizedTypes {
+		return
+	}
+	for _, v := range [...]interface{}{
+		float32(0),
+		float64(0),
+		uintptr(0),
+		uint(0),
+		uint8(0),
+		uint16(0),
+		uint32(0),
+		uint64(0),
+		uintptr(0),
+		int(0),
+		int8(0),
+		int16(0),
+		int32(0),
+		int64(0),
+		bool(false),
+		string(""),
+		Raw{},
+		[]byte(nil),
+	} {
+		rt := reflect.TypeOf(v)
+		recognizedRtids = append(recognizedRtids, rt2id(rt))
+		recognizedRtidPtrs = append(recognizedRtidPtrs, rt2id(reflect.PtrTo(rt)))
+	}
+}
+
+func containsU(s []uintptr, v uintptr) bool {
+	// return false // TODO: REMOVE
+	h, i, j := 0, 0, len(s)
+	for i < j {
+		h = i + (j-i)/2
+		if s[h] < v {
+			i = h + 1
+		} else {
+			j = h
+		}
+	}
+	if i < len(s) && s[i] == v {
+		return true
+	}
+	return false
+}
+
+func isRecognizedRtid(rtid uintptr) bool {
+	return containsU(recognizedRtids, rtid)
+}
+
+func isRecognizedRtidPtr(rtid uintptr) bool {
+	return containsU(recognizedRtidPtrs, rtid)
+}
+
+func isRecognizedRtidOrPtr(rtid uintptr) bool {
+	return containsU(recognizedRtidOrPtrs, rtid)
+}
+
 // Selfer defines methods by which a value can encode or decode itself.
 //
 // Any type which implements Selfer will be able to encode or decode itself.
@@ -336,6 +497,7 @@ type BasicHandle struct {
 	extHandle
 	EncodeOptions
 	DecodeOptions
+	noBuiltInTypeChecker
 }
 
 func (x *BasicHandle) getBasicHandle() *BasicHandle {
@@ -343,10 +505,10 @@ func (x *BasicHandle) getBasicHandle() *BasicHandle {
 }
 
 func (x *BasicHandle) getTypeInfo(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
-	if x.TypeInfos != nil {
-		return x.TypeInfos.get(rtid, rt)
+	if x.TypeInfos == nil {
+		return defTypeInfos.get(rtid, rt)
 	}
-	return defTypeInfos.get(rtid, rt)
+	return x.TypeInfos.get(rtid, rt)
 }
 
 // Handle is the interface for a specific encoding format.
@@ -359,6 +521,8 @@ type Handle interface {
 	newEncDriver(w *Encoder) encDriver
 	newDecDriver(r *Decoder) decDriver
 	isBinary() bool
+	hasElemSeparators() bool
+	IsBuiltinType(rtid uintptr) bool
 }
 
 // Raw represents raw formatted bytes.
@@ -476,9 +640,6 @@ func (x *setExtWrapper) UpdateExt(dest interface{}, v interface{}) {
 	x.i.UpdateExt(dest, v)
 }
 
-// type errorString string
-// func (x errorString) Error() string { return string(x) }
-
 type binaryEncodingType struct{}
 
 func (_ binaryEncodingType) isBinary() bool { return true }
@@ -489,15 +650,23 @@ func (_ textEncodingType) isBinary() bool { return false }
 
 // noBuiltInTypes is embedded into many types which do not support builtins
 // e.g. msgpack, simple, cbor.
-type noBuiltInTypes struct{}
 
-func (_ noBuiltInTypes) IsBuiltinType(rt uintptr) bool           { return false }
+type noBuiltInTypeChecker struct{}
+
+func (_ noBuiltInTypeChecker) IsBuiltinType(rt uintptr) bool { return false }
+
+type noBuiltInTypes struct{ noBuiltInTypeChecker }
+
 func (_ noBuiltInTypes) EncodeBuiltin(rt uintptr, v interface{}) {}
 func (_ noBuiltInTypes) DecodeBuiltin(rt uintptr, v interface{}) {}
 
-type noStreamingCodec struct{}
+// type noStreamingCodec struct{}
+// func (_ noStreamingCodec) CheckBreak() bool { return false }
+// func (_ noStreamingCodec) hasElemSeparators() bool { return false }
 
-func (_ noStreamingCodec) CheckBreak() bool { return false }
+type noElemSeparators struct{}
+
+func (_ noElemSeparators) hasElemSeparators() (v bool) { return }
 
 // bigenHelper.
 // Users must already slice the x completely, because we will not reslice.
@@ -559,7 +728,7 @@ func (o *extHandle) SetExt(rt reflect.Type, tag uint64, ext Ext) (err error) {
 		return
 	}
 
-	rtid := reflect.ValueOf(rt).Pointer()
+	rtid := rt2id(rt)
 	for _, v := range *o {
 		if v.rtid == rtid {
 			v.tag, v.ext = tag, ext
@@ -596,64 +765,44 @@ func (o extHandle) getExtForTag(tag uint64) *extTypeTagFn {
 	return nil
 }
 
+const maxLevelsEmbedding = 16
+
 type structFieldInfo struct {
 	encName   string // encode name
 	fieldName string // field name
 
-	// only one of 'i' or 'is' can be set. If 'i' is -1, then 'is' has been set.
-
-	is        []int // (recursive/embedded) field index in struct
-	i         int16 // field index in struct
+	is        [maxLevelsEmbedding]uint16 // (recursive/embedded) field index in struct
+	nis       uint8                      // num levels of embedding. if 1, then it's not embedded.
 	omitEmpty bool
 	toArray   bool // if field is _struct, is the toArray set?
 }
 
-// func (si *structFieldInfo) isZero() bool {
-// 	return si.encName == "" && len(si.is) == 0 && si.i == 0 && !si.omitEmpty && !si.toArray
-// }
+func (si *structFieldInfo) setToZeroValue(v reflect.Value) {
+	if v, valid := si.field(v, false); valid {
+		v.Set(reflect.Zero(v.Type()))
+	}
+}
 
 // rv returns the field of the struct.
 // If anonymous, it returns an Invalid
-func (si *structFieldInfo) field(v reflect.Value, update bool) (rv2 reflect.Value) {
-	if si.i != -1 {
-		v = v.Field(int(si.i))
-		return v
-	}
+func (si *structFieldInfo) field(v reflect.Value, update bool) (rv2 reflect.Value, valid bool) {
 	// replicate FieldByIndex
-	for _, x := range si.is {
-		for v.Kind() == reflect.Ptr {
-			if v.IsNil() {
-				if !update {
-					return
-				}
-				v.Set(reflect.New(v.Type().Elem()))
-			}
-			v = v.Elem()
+	for i, x := range si.is {
+		if uint8(i) == si.nis {
+			break
 		}
-		v = v.Field(x)
+		if v, valid = baseStructRv(v, update); !valid {
+			return
+		}
+		v = v.Field(int(x))
 	}
-	return v
+
+	return v, true
 }
 
-func (si *structFieldInfo) setToZeroValue(v reflect.Value) {
-	if si.i != -1 {
-		v = v.Field(int(si.i))
-		v.Set(reflect.Zero(v.Type()))
-		// v.Set(reflect.New(v.Type()).Elem())
-		// v.Set(reflect.New(v.Type()))
-	} else {
-		// replicate FieldByIndex
-		for _, x := range si.is {
-			for v.Kind() == reflect.Ptr {
-				if v.IsNil() {
-					return
-				}
-				v = v.Elem()
-			}
-			v = v.Field(x)
-		}
-		v.Set(reflect.Zero(v.Type()))
-	}
+func (si *structFieldInfo) fieldval(v reflect.Value, update bool) reflect.Value {
+	v, _ = si.field(v, update)
+	return v
 }
 
 func parseStructFieldInfo(fname string, stag string) *structFieldInfo {
@@ -697,6 +846,97 @@ func (p sfiSortedByEncName) Swap(i, j int) {
 	p[i], p[j] = p[j], p[i]
 }
 
+const structFieldNodeNumToCache = 4
+
+type structFieldNodeCache struct {
+	rv  [structFieldNodeNumToCache]reflect.Value
+	idx [structFieldNodeNumToCache]uint32
+	num uint8
+}
+
+func (x *structFieldNodeCache) get(key uint32) (fv reflect.Value, valid bool) {
+	// defer func() { fmt.Printf(">>>> found in cache2? %v\n", valid) }()
+	for i, k := range &x.idx {
+		if uint8(i) == x.num {
+			return // break
+		}
+		if key == k {
+			return x.rv[i], true
+		}
+	}
+	return
+}
+
+func (x *structFieldNodeCache) tryAdd(fv reflect.Value, key uint32) {
+	if x.num < structFieldNodeNumToCache {
+		x.rv[x.num] = fv
+		x.idx[x.num] = key
+		x.num++
+		return
+	}
+}
+
+type structFieldNode struct {
+	v      reflect.Value
+	cache2 structFieldNodeCache
+	cache3 structFieldNodeCache
+	update bool
+}
+
+func (x *structFieldNode) field(si *structFieldInfo) (fv reflect.Value) {
+	// return si.fieldval(x.v, x.update)
+	// Note: we only cache if nis=2 or nis=3 i.e. up to 2 levels of embedding
+	// This mostly saves us time on the repeated calls to v.Elem, v.Field, etc.
+	var valid bool
+	switch si.nis {
+	case 1:
+		fv = x.v.Field(int(si.is[0]))
+	case 2:
+		if fv, valid = x.cache2.get(uint32(si.is[0])); valid {
+			fv = fv.Field(int(si.is[1]))
+			return
+		}
+		fv = x.v.Field(int(si.is[0]))
+		if fv, valid = baseStructRv(fv, x.update); !valid {
+			return
+		}
+		x.cache2.tryAdd(fv, uint32(si.is[0]))
+		fv = fv.Field(int(si.is[1]))
+	case 3:
+		var key uint32 = uint32(si.is[0])<<16 | uint32(si.is[1])
+		if fv, valid = x.cache3.get(key); valid {
+			fv = fv.Field(int(si.is[2]))
+			return
+		}
+		fv = x.v.Field(int(si.is[0]))
+		if fv, valid = baseStructRv(fv, x.update); !valid {
+			return
+		}
+		fv = fv.Field(int(si.is[1]))
+		if fv, valid = baseStructRv(fv, x.update); !valid {
+			return
+		}
+		x.cache3.tryAdd(fv, key)
+		fv = fv.Field(int(si.is[2]))
+	default:
+		fv, _ = si.field(x.v, x.update)
+	}
+	return
+}
+
+func baseStructRv(v reflect.Value, update bool) (v2 reflect.Value, valid bool) {
+	for v.Kind() == reflect.Ptr {
+		if v.IsNil() {
+			if !update {
+				return
+			}
+			v.Set(reflect.New(v.Type().Elem()))
+		}
+		v = v.Elem()
+	}
+	return v, true
+}
+
 // typeInfo keeps information about each type referenced in the encode/decode sequence.
 //
 // During an encode/decode sequence, we work as below:
@@ -711,6 +951,7 @@ type typeInfo struct {
 
 	rt   reflect.Type
 	rtid uintptr
+	// rv0  reflect.Value // saved zero value, used if immutableKind
 
 	numMeth uint16 // number of methods
 
@@ -720,6 +961,8 @@ type typeInfo struct {
 	baseId    uintptr
 	baseIndir int8 // number of indirections to get to base
 
+	anyOmitEmpty bool
+
 	mbs bool // base type (T or *T) is a MapBySlice
 
 	bm        bool // base type (T or *T) is a binaryMarshaler
@@ -743,42 +986,51 @@ type typeInfo struct {
 	toArray bool // whether this (struct) type should be encoded as an array
 }
 
+// define length beyond which we do a binary search instead of a linear search.
+// From our testing, linear search seems faster than binary search up to 16-field structs.
+// However, we set to 8 similar to what python does for hashtables.
+const indexForEncNameBinarySearchThreshold = 8
+
 func (ti *typeInfo) indexForEncName(name string) int {
 	// NOTE: name may be a stringView, so don't pass it to another function.
 	//tisfi := ti.sfi
-	const binarySearchThreshold = 16
-	if sfilen := len(ti.sfi); sfilen < binarySearchThreshold {
-		// linear search. faster than binary search in my testing up to 16-field structs.
+	sfilen := len(ti.sfi)
+	if sfilen < indexForEncNameBinarySearchThreshold {
 		for i, si := range ti.sfi {
 			if si.encName == name {
 				return i
 			}
 		}
-	} else {
-		// binary search. adapted from sort/search.go.
-		h, i, j := 0, 0, sfilen
-		for i < j {
-			h = i + (j-i)/2
-			if ti.sfi[h].encName < name {
-				i = h + 1
-			} else {
-				j = h
-			}
-		}
-		if i < sfilen && ti.sfi[i].encName == name {
-			return i
+		return -1
+	}
+	// binary search. adapted from sort/search.go.
+	h, i, j := 0, 0, sfilen
+	for i < j {
+		h = i + (j-i)/2
+		if ti.sfi[h].encName < name {
+			i = h + 1
+		} else {
+			j = h
 		}
 	}
+	if i < sfilen && ti.sfi[i].encName == name {
+		return i
+	}
 	return -1
 }
 
+type rtid2ti struct {
+	rtid uintptr
+	ti   *typeInfo
+}
+
 // TypeInfos caches typeInfo for each type on first inspection.
 //
 // It is configured with a set of tag keys, which are used to get
 // configuration for the type.
 type TypeInfos struct {
-	infos map[uintptr]*typeInfo
-	mu    sync.RWMutex
+	infos atomicTypeInfoSlice // formerly map[uintptr]*typeInfo, now *[]rtid2ti
+	mu    sync.Mutex
 	tags  []string
 }
 
@@ -787,7 +1039,7 @@ type TypeInfos struct {
 // This allows users customize the struct tag keys which contain configuration
 // of their types.
 func NewTypeInfos(tags []string) *TypeInfos {
-	return &TypeInfos{tags: tags, infos: make(map[uintptr]*typeInfo, 64)}
+	return &TypeInfos{tags: tags}
 }
 
 func (x *TypeInfos) structTag(t reflect.StructTag) (s string) {
@@ -802,20 +1054,44 @@ func (x *TypeInfos) structTag(t reflect.StructTag) (s string) {
 	return
 }
 
+func (x *TypeInfos) find(sp *[]rtid2ti, rtid uintptr) (idx int, ti *typeInfo) {
+	// binary search. adapted from sort/search.go.
+	// if sp == nil {
+	// 	return -1, nil
+	// }
+	s := *sp
+	h, i, j := 0, 0, len(s)
+	for i < j {
+		h = i + (j-i)/2
+		if s[h].rtid < rtid {
+			i = h + 1
+		} else {
+			j = h
+		}
+	}
+	if i < len(s) && s[i].rtid == rtid {
+		return i, s[i].ti
+	}
+	return i, nil
+}
+
 func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
-	var ok bool
-	x.mu.RLock()
-	pti, ok = x.infos[rtid]
-	x.mu.RUnlock()
-	if ok {
-		return
+	sp := x.infos.load()
+	var idx int
+	if sp != nil {
+		idx, pti = x.find(sp, rtid)
+		if pti != nil {
+			return
+		}
 	}
 
 	// do not hold lock while computing this.
 	// it may lead to duplication, but that's ok.
 	ti := typeInfo{rt: rt, rtid: rtid}
-	ti.numMeth = uint16(rt.NumMethod())
+	// ti.rv0 = reflect.Zero(rt)
 
+	ti.numMeth = uint16(rt.NumMethod())
+	var ok bool
 	var indir int8
 	if ok, indir = implementsIntf(rt, binaryMarshalerTyp); ok {
 		ti.bm, ti.bmIndir = true, indir
@@ -854,7 +1130,7 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
 		ti.baseId = rtid
 	} else {
 		ti.base = pt
-		ti.baseId = reflect.ValueOf(pt).Pointer()
+		ti.baseId = rt2id(pt)
 		ti.baseIndir = ptIndir
 	}
 
@@ -865,27 +1141,41 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
 			ti.toArray = siInfo.toArray
 			omitEmpty = siInfo.omitEmpty
 		}
-		pi := rgetPool.Get()
-		pv := pi.(*rgetPoolT)
+		pp, pi := pool.tiLoad()
+		pv := pi.(*typeInfoLoadArray)
 		pv.etypes[0] = ti.baseId
-		vv := rgetT{pv.fNames[:0], pv.encNames[:0], pv.etypes[:1], pv.sfis[:0]}
+		vv := typeInfoLoad{pv.fNames[:0], pv.encNames[:0], pv.etypes[:1], pv.sfis[:0]}
 		x.rget(rt, rtid, omitEmpty, nil, &vv)
-		ti.sfip, ti.sfi = rgetResolveSFI(vv.sfis, pv.sfiidx[:0])
-		rgetPool.Put(pi)
+		ti.sfip, ti.sfi, ti.anyOmitEmpty = rgetResolveSFI(vv.sfis, pv.sfiidx[:0])
+		pp.Put(pi)
 	}
 	// sfi = sfip
 
+	var vs []rtid2ti
 	x.mu.Lock()
-	if pti, ok = x.infos[rtid]; !ok {
+	sp = x.infos.load()
+	if sp == nil {
 		pti = &ti
-		x.infos[rtid] = pti
+		vs = []rtid2ti{{rtid, pti}}
+		x.infos.store(&vs)
+	} else {
+		idx, pti = x.find(sp, rtid)
+		if pti == nil {
+			s := *sp
+			pti = &ti
+			vs = make([]rtid2ti, len(s)+1)
+			copy(vs, s[:idx])
+			vs[idx] = rtid2ti{rtid, pti}
+			copy(vs[idx+1:], s[idx:])
+			x.infos.store(&vs)
+		}
 	}
 	x.mu.Unlock()
 	return
 }
 
 func (x *TypeInfos) rget(rt reflect.Type, rtid uintptr, omitEmpty bool,
-	indexstack []int, pv *rgetT,
+	indexstack []uint16, pv *typeInfoLoad,
 ) {
 	// Read up fields and store how to access the value.
 	//
@@ -895,10 +1185,13 @@ func (x *TypeInfos) rget(rt reflect.Type, rtid uintptr, omitEmpty bool,
 	// Note: we consciously use slices, not a map, to simulate a set.
 	//       Typically, types have < 16 fields,
 	//       and iteration using equals is faster than maps there
-
+	flen := rt.NumField()
+	if flen > (1<<maxLevelsEmbedding - 1) {
+		panic(fmt.Errorf("codec: types with more than %v fields are not supported - has %v fields", (1<<maxLevelsEmbedding - 1), flen))
+	}
 LOOP:
-	for j, jlen := 0, rt.NumField(); j < jlen; j++ {
-		f := rt.Field(j)
+	for j, jlen := uint16(0), uint16(flen); j < jlen; j++ {
+		f := rt.Field(int(j))
 		fkind := f.Type.Kind()
 		// skip if a func type, or is unexported, or structTag value == "-"
 		switch fkind {
@@ -932,7 +1225,7 @@ LOOP:
 				}
 				if ft.Kind() == reflect.Struct {
 					// if etypes contains this, don't call rget again (as fields are already seen here)
-					ftid := reflect.ValueOf(ft).Pointer()
+					ftid := rt2id(ft)
 					// We cannot recurse forever, but we need to track other field depths.
 					// So - we break if we see a type twice (not the first time).
 					// This should be sufficient to handle an embedded type that refers to its
@@ -950,7 +1243,7 @@ LOOP:
 					}
 					if processIt {
 						pv.etypes = append(pv.etypes, ftid)
-						indexstack2 := make([]int, len(indexstack)+1)
+						indexstack2 := make([]uint16, len(indexstack)+1)
 						copy(indexstack2, indexstack)
 						indexstack2[len(indexstack)] = j
 						// indexstack2 := append(append(make([]int, 0, len(indexstack)+4), indexstack...), j)
@@ -982,15 +1275,12 @@ LOOP:
 		pv.encNames = append(pv.encNames, si.encName)
 
 		// si.ikind = int(f.Type.Kind())
-		if len(indexstack) == 0 {
-			si.i = int16(j)
-		} else {
-			si.i = -1
-			si.is = make([]int, len(indexstack)+1)
-			copy(si.is, indexstack)
-			si.is[len(indexstack)] = j
-			// si.is = append(append(make([]int, 0, len(indexstack)+4), indexstack...), j)
+		if len(indexstack) > maxLevelsEmbedding-1 {
+			panic(fmt.Errorf("codec: only supports up to %v depth of embedding - type has %v depth", maxLevelsEmbedding-1, len(indexstack)))
 		}
+		si.nis = uint8(len(indexstack)) + 1
+		copy(si.is[:], indexstack)
+		si.is[len(indexstack)] = j
 
 		if omitEmpty {
 			si.omitEmpty = true
@@ -1001,16 +1291,16 @@ LOOP:
 
 // resolves the struct field info got from a call to rget.
 // Returns a trimmed, unsorted and sorted []*structFieldInfo.
-func rgetResolveSFI(x []*structFieldInfo, pv []sfiIdx) (y, z []*structFieldInfo) {
+func rgetResolveSFI(x []*structFieldInfo, pv []sfiIdx) (y, z []*structFieldInfo, anyOmitEmpty bool) {
 	var n int
 	for i, v := range x {
-		xn := v.encName //TODO: fieldName or encName? use encName for now.
+		xn := v.encName // TODO: fieldName or encName? use encName for now.
 		var found bool
 		for j, k := range pv {
 			if k.name == xn {
 				// one of them must be reset to nil, and the index updated appropriately to the other one
-				if len(v.is) == len(x[k.index].is) {
-				} else if len(v.is) < len(x[k.index].is) {
+				if v.nis == x[k.index].nis {
+				} else if v.nis < x[k.index].nis {
 					pv[j].index = i
 					if x[k.index] != nil {
 						x[k.index] = nil
@@ -1038,6 +1328,9 @@ func rgetResolveSFI(x []*structFieldInfo, pv []sfiIdx) (y, z []*structFieldInfo)
 		if v == nil {
 			continue
 		}
+		if !anyOmitEmpty && v.omitEmpty {
+			anyOmitEmpty = true
+		}
 		y[n] = v
 		n++
 	}
@@ -1048,15 +1341,33 @@ func rgetResolveSFI(x []*structFieldInfo, pv []sfiIdx) (y, z []*structFieldInfo)
 	return
 }
 
+func xprintf(format string, a ...interface{}) {
+	if xDebug {
+		fmt.Fprintf(os.Stderr, format, a...)
+	}
+}
+
 func panicToErr(err *error) {
 	if recoverPanicToErr {
 		if x := recover(); x != nil {
-			//debug.PrintStack()
+			// if false && xDebug {
+			// 	fmt.Printf("panic'ing with: %v\n", x)
+			// 	debug.PrintStack()
+			// }
 			panicValToErr(x, err)
 		}
 	}
 }
 
+func panicToErrs2(err1, err2 *error) {
+	if recoverPanicToErr {
+		if x := recover(); x != nil {
+			panicValToErr(x, err1)
+			panicValToErr(x, err2)
+		}
+	}
+}
+
 // func doPanic(tag string, format string, params ...interface{}) {
 // 	params2 := make([]interface{}, len(params)+1)
 // 	params2[0] = tag
@@ -1065,24 +1376,266 @@ func panicToErr(err *error) {
 // }
 
 func isImmutableKind(k reflect.Kind) (v bool) {
-	return false ||
-		k == reflect.Int ||
-		k == reflect.Int8 ||
-		k == reflect.Int16 ||
-		k == reflect.Int32 ||
-		k == reflect.Int64 ||
-		k == reflect.Uint ||
-		k == reflect.Uint8 ||
-		k == reflect.Uint16 ||
-		k == reflect.Uint32 ||
-		k == reflect.Uint64 ||
-		k == reflect.Uintptr ||
-		k == reflect.Float32 ||
-		k == reflect.Float64 ||
-		k == reflect.Bool ||
-		k == reflect.String
+	return immutableKindsSet[k]
+	// return false ||
+	// 	k == reflect.Int ||
+	// 	k == reflect.Int8 ||
+	// 	k == reflect.Int16 ||
+	// 	k == reflect.Int32 ||
+	// 	k == reflect.Int64 ||
+	// 	k == reflect.Uint ||
+	// 	k == reflect.Uint8 ||
+	// 	k == reflect.Uint16 ||
+	// 	k == reflect.Uint32 ||
+	// 	k == reflect.Uint64 ||
+	// 	k == reflect.Uintptr ||
+	// 	k == reflect.Float32 ||
+	// 	k == reflect.Float64 ||
+	// 	k == reflect.Bool ||
+	// 	k == reflect.String
 }
 
+// ----
+
+type codecFnInfo struct {
+	ti    *typeInfo
+	xfFn  Ext
+	xfTag uint64
+	seq   seqType
+	addr  bool
+}
+
+// codecFn encapsulates the captured variables and the encode function.
+// This way, we only do some calculations one times, and pass to the
+// code block that should be called (encapsulated in a function)
+// instead of executing the checks every time.
+type codecFn struct {
+	i  codecFnInfo
+	fe func(*Encoder, *codecFnInfo, reflect.Value)
+	fd func(*Decoder, *codecFnInfo, reflect.Value)
+}
+
+type codecRtidFn struct {
+	rtid uintptr
+	fn   codecFn
+}
+
+type codecFner struct {
+	hh Handle
+	h  *BasicHandle
+	cs [arrayCacheLen]*[arrayCacheLen]codecRtidFn
+	s  []*[arrayCacheLen]codecRtidFn
+	sn uint32
+	be bool
+	js bool
+	cf [arrayCacheLen]codecRtidFn
+}
+
+func (c *codecFner) reset(hh Handle) {
+	c.hh = hh
+	c.h = hh.getBasicHandle()
+	_, c.js = hh.(*JsonHandle)
+	c.be = hh.isBinary()
+}
+
+func (c *codecFner) get(rt reflect.Type, checkFastpath, checkCodecSelfer bool) (fn *codecFn) {
+	rtid := rt2id(rt)
+	var j uint32
+	var sn uint32 = c.sn
+	if sn == 0 {
+		c.s = c.cs[:1]
+		c.s[0] = &c.cf
+		c.cf[0].rtid = rtid
+		fn = &(c.cf[0].fn)
+		c.sn = 1
+	} else {
+	LOOP1:
+		for _, x := range c.s {
+			for i := range x {
+				if j == sn {
+					break LOOP1
+				}
+				if x[i].rtid == rtid {
+					fn = &(x[i].fn)
+					return
+				}
+				j++
+			}
+		}
+		sx, sy := sn/arrayCacheLen, sn%arrayCacheLen
+		if sy == 0 {
+			c.s = append(c.s, &[arrayCacheLen]codecRtidFn{})
+		}
+		c.s[sx][sy].rtid = rtid
+		fn = &(c.s[sx][sy].fn)
+		c.sn++
+	}
+
+	ti := c.h.getTypeInfo(rtid, rt)
+	fi := &(fn.i)
+	fi.ti = ti
+
+	if checkCodecSelfer && ti.cs {
+		fn.fe = (*Encoder).selferMarshal
+		fn.fd = (*Decoder).selferUnmarshal
+	} else if rtid == rawTypId {
+		fn.fe = (*Encoder).raw
+		fn.fd = (*Decoder).raw
+	} else if rtid == rawExtTypId {
+		fn.fe = (*Encoder).rawExt
+		fn.fd = (*Decoder).rawExt
+		fn.i.addr = true
+	} else if c.hh.IsBuiltinType(rtid) {
+		fn.fe = (*Encoder).builtin
+		fn.fd = (*Decoder).builtin
+		fn.i.addr = true
+	} else if xfFn := c.h.getExt(rtid); xfFn != nil {
+		fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
+		fn.fe = (*Encoder).ext
+		fn.fd = (*Decoder).ext
+		fn.i.addr = true
+	} else if supportMarshalInterfaces && c.be && ti.bm {
+		fn.fe = (*Encoder).binaryMarshal
+		fn.fd = (*Decoder).binaryUnmarshal
+	} else if supportMarshalInterfaces && !c.be && c.js && ti.jm {
+		//If JSON, we should check JSONMarshal before textMarshal
+		fn.fe = (*Encoder).jsonMarshal
+		fn.fd = (*Decoder).jsonUnmarshal
+	} else if supportMarshalInterfaces && !c.be && ti.tm {
+		fn.fe = (*Encoder).textMarshal
+		fn.fd = (*Decoder).textUnmarshal
+	} else {
+		rk := rt.Kind()
+		if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) {
+			if rt.PkgPath() == "" { // un-named slice or map
+				if idx := fastpathAV.index(rtid); idx != -1 {
+					fn.fe = fastpathAV[idx].encfn
+					fn.fd = fastpathAV[idx].decfn
+					fn.i.addr = true
+				}
+			} else {
+				// use mapping for underlying type if there
+				var rtu reflect.Type
+				if rk == reflect.Map {
+					rtu = reflect.MapOf(rt.Key(), rt.Elem())
+				} else {
+					rtu = reflect.SliceOf(rt.Elem())
+				}
+				rtuid := rt2id(rtu)
+				if idx := fastpathAV.index(rtuid); idx != -1 {
+					xfnf := fastpathAV[idx].encfn
+					xrt := fastpathAV[idx].rt
+					fn.fe = func(e *Encoder, xf *codecFnInfo, xrv reflect.Value) {
+						xfnf(e, xf, xrv.Convert(xrt))
+					}
+					fn.i.addr = true
+					xfnf2 := fastpathAV[idx].decfn
+					fn.fd = func(d *Decoder, xf *codecFnInfo, xrv reflect.Value) {
+						xfnf2(d, xf, xrv.Convert(reflect.PtrTo(xrt)))
+					}
+				}
+			}
+		}
+		if fn.fe == nil && fn.fd == nil {
+			switch rk {
+			case reflect.Bool:
+				fn.fe = (*Encoder).kBool
+				fn.fd = (*Decoder).kBool
+			case reflect.String:
+				fn.fe = (*Encoder).kString
+				fn.fd = (*Decoder).kString
+			case reflect.Int:
+				fn.fd = (*Decoder).kInt
+				fn.fe = (*Encoder).kInt
+			case reflect.Int8:
+				fn.fe = (*Encoder).kInt
+				fn.fd = (*Decoder).kInt8
+			case reflect.Int16:
+				fn.fe = (*Encoder).kInt
+				fn.fd = (*Decoder).kInt16
+			case reflect.Int32:
+				fn.fe = (*Encoder).kInt
+				fn.fd = (*Decoder).kInt32
+			case reflect.Int64:
+				fn.fe = (*Encoder).kInt
+				fn.fd = (*Decoder).kInt64
+			case reflect.Uint:
+				fn.fd = (*Decoder).kUint
+				fn.fe = (*Encoder).kUint
+			case reflect.Uint8:
+				fn.fe = (*Encoder).kUint
+				fn.fd = (*Decoder).kUint8
+			case reflect.Uint16:
+				fn.fe = (*Encoder).kUint
+				fn.fd = (*Decoder).kUint16
+			case reflect.Uint32:
+				fn.fe = (*Encoder).kUint
+				fn.fd = (*Decoder).kUint32
+			case reflect.Uint64:
+				fn.fe = (*Encoder).kUint
+				fn.fd = (*Decoder).kUint64
+				// case reflect.Ptr:
+				// 	fn.fd = (*Decoder).kPtr
+			case reflect.Uintptr:
+				fn.fe = (*Encoder).kUint
+				fn.fd = (*Decoder).kUintptr
+			case reflect.Float32:
+				fn.fe = (*Encoder).kFloat32
+				fn.fd = (*Decoder).kFloat32
+			case reflect.Float64:
+				fn.fe = (*Encoder).kFloat64
+				fn.fd = (*Decoder).kFloat64
+			case reflect.Invalid:
+				fn.fe = (*Encoder).kInvalid
+			case reflect.Chan:
+				fi.seq = seqTypeChan
+				fn.fe = (*Encoder).kSlice
+				fn.fd = (*Decoder).kSlice
+			case reflect.Slice:
+				fi.seq = seqTypeSlice
+				fn.fe = (*Encoder).kSlice
+				fn.fd = (*Decoder).kSlice
+			case reflect.Array:
+				fi.seq = seqTypeArray
+				fn.fe = (*Encoder).kSlice
+				fi.addr = false
+				rt2 := reflect.SliceOf(rt.Elem())
+				fn.fd = func(d *Decoder, xf *codecFnInfo, xrv reflect.Value) {
+					// println(">>>>>> decoding an array ... ")
+					d.cf.get(rt2, true, false).fd(d, xf, xrv.Slice(0, xrv.Len()))
+					// println(">>>>>> decoding an array ... DONE")
+				}
+				// fn.fd = (*Decoder).kArray
+			case reflect.Struct:
+				if ti.anyOmitEmpty {
+					fn.fe = (*Encoder).kStruct
+				} else {
+					fn.fe = (*Encoder).kStructNoOmitempty
+				}
+				fn.fd = (*Decoder).kStruct
+				// reflect.Ptr and reflect.Interface are handled already by preEncodeValue
+				// case reflect.Ptr:
+				// 	fn.fe = (*Encoder).kPtr
+				// case reflect.Interface:
+				// 	fn.fe = (*Encoder).kInterface
+			case reflect.Map:
+				fn.fe = (*Encoder).kMap
+				fn.fd = (*Decoder).kMap
+			case reflect.Interface:
+				// encode: reflect.Interface are handled already by preEncodeValue
+				fn.fd = (*Decoder).kInterface
+			default:
+				fn.fe = (*Encoder).kErr
+				fn.fd = (*Decoder).kErr
+			}
+		}
+	}
+
+	return
+}
+
+// ----
+
 // these functions must be inlinable, and not call anybody
 type checkOverflow struct{}
 
@@ -1140,6 +1693,7 @@ func isNaN(f float64) bool { return f != f }
 
 type intSlice []int64
 type uintSlice []uint64
+type uintptrSlice []uintptr
 type floatSlice []float64
 type boolSlice []bool
 type stringSlice []string
@@ -1153,6 +1707,10 @@ func (p uintSlice) Len() int           { return len(p) }
 func (p uintSlice) Less(i, j int) bool { return p[i] < p[j] }
 func (p uintSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
+func (p uintptrSlice) Len() int           { return len(p) }
+func (p uintptrSlice) Less(i, j int) bool { return p[i] < p[j] }
+func (p uintptrSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
 func (p floatSlice) Len() int { return len(p) }
 func (p floatSlice) Less(i, j int) bool {
 	return p[i] < p[j] || isNaN(p[i]) && !isNaN(p[j])
@@ -1249,7 +1807,6 @@ type set []uintptr
 
 func (s *set) add(v uintptr) (exists bool) {
 	// e.ci is always nil, or len >= 1
-	// defer func() { fmt.Printf("$$$$$$$$$$$ cirRef Add: %v, exists: %v\n", v, exists) }()
 	x := *s
 	if x == nil {
 		x = make([]uintptr, 1, 8)
@@ -1290,7 +1847,6 @@ func (s *set) add(v uintptr) (exists bool) {
 }
 
 func (s *set) remove(v uintptr) (exists bool) {
-	// defer func() { fmt.Printf("$$$$$$$$$$$ cirRef Rm: %v, exists: %v\n", v, exists) }()
 	x := *s
 	if len(x) == 0 {
 		return
@@ -1312,3 +1868,77 @@ func (s *set) remove(v uintptr) (exists bool) {
 	}
 	return
 }
+
+// ------
+
+// bitset types are better than [256]bool, because they permit the whole
+// bitset array being on a single cache line and use less memory.
+
+// given x > 0 and n > 0 and x is exactly 2^n, then pos/x === pos>>n AND pos%x === pos&(x-1).
+// consequently, pos/32 === pos>>5, pos/16 === pos>>4, pos/8 === pos>>3, pos%8 == pos&7
+
+type bitset256 [32]byte
+
+func (x *bitset256) set(pos byte) {
+	x[pos>>3] |= (1 << (pos & 7))
+}
+func (x *bitset256) unset(pos byte) {
+	x[pos>>3] &^= (1 << (pos & 7))
+}
+func (x *bitset256) isset(pos byte) bool {
+	return x[pos>>3]&(1<<(pos&7)) != 0
+}
+
+type bitset128 [16]byte
+
+func (x *bitset128) set(pos byte) {
+	x[pos>>3] |= (1 << (pos & 7))
+}
+func (x *bitset128) unset(pos byte) {
+	x[pos>>3] &^= (1 << (pos & 7))
+}
+func (x *bitset128) isset(pos byte) bool {
+	return x[pos>>3]&(1<<(pos&7)) != 0
+}
+
+// ------------
+
+type pooler struct {
+	// for stringRV
+	strRv8, strRv16, strRv32, strRv64, strRv128 sync.Pool
+	// for the decNaked
+	dn     sync.Pool
+	tiload sync.Pool
+}
+
+func (p *pooler) init() {
+	p.strRv8.New = func() interface{} { return new([8]stringRv) }
+	p.strRv16.New = func() interface{} { return new([16]stringRv) }
+	p.strRv32.New = func() interface{} { return new([32]stringRv) }
+	p.strRv64.New = func() interface{} { return new([64]stringRv) }
+	p.strRv128.New = func() interface{} { return new([128]stringRv) }
+	p.dn.New = func() interface{} { x := new(decNaked); x.init(); return x }
+	p.tiload.New = func() interface{} { return new(typeInfoLoadArray) }
+}
+
+func (p *pooler) stringRv8() (sp *sync.Pool, v interface{}) {
+	return &p.strRv8, p.strRv8.Get()
+}
+func (p *pooler) stringRv16() (sp *sync.Pool, v interface{}) {
+	return &p.strRv16, p.strRv16.Get()
+}
+func (p *pooler) stringRv32() (sp *sync.Pool, v interface{}) {
+	return &p.strRv32, p.strRv32.Get()
+}
+func (p *pooler) stringRv64() (sp *sync.Pool, v interface{}) {
+	return &p.strRv64, p.strRv64.Get()
+}
+func (p *pooler) stringRv128() (sp *sync.Pool, v interface{}) {
+	return &p.strRv128, p.strRv128.Get()
+}
+func (p *pooler) decNaked() (sp *sync.Pool, v interface{}) {
+	return &p.dn, p.dn.Get()
+}
+func (p *pooler) tiLoad() (sp *sync.Pool, v interface{}) {
+	return &p.tiload, p.tiload.Get()
+}
diff --git a/vendor/github.com/ugorji/go/codec/helper_internal.go b/vendor/github.com/ugorji/go/codec/helper_internal.go
index 5d0727f77f6..eb18e2ccaee 100644
--- a/vendor/github.com/ugorji/go/codec/helper_internal.go
+++ b/vendor/github.com/ugorji/go/codec/helper_internal.go
@@ -219,24 +219,3 @@ func growCap(oldCap, unit, num int) (newCap int) {
 	}
 	return
 }
-
-func expandSliceValue(s reflect.Value, num int) reflect.Value {
-	if num <= 0 {
-		return s
-	}
-	l0 := s.Len()
-	l1 := l0 + num // new slice length
-	if l1 < l0 {
-		panic("ExpandSlice: slice overflow")
-	}
-	c0 := s.Cap()
-	if l1 <= c0 {
-		return s.Slice(0, l1)
-	}
-	st := s.Type()
-	c1 := growCap(c0, int(st.Elem().Size()), num)
-	s2 := reflect.MakeSlice(st, l1, c1)
-	// println("expandslicevalue: cap-old: ", c0, ", cap-new: ", c1, ", len-new: ", l1)
-	reflect.Copy(s2, s)
-	return s2
-}
diff --git a/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
index 8b06a004590..9d9d048ea4a 100644
--- a/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
+++ b/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
@@ -1,13 +1,21 @@
-// +build !unsafe
+// +build !go1.7 safe appengine
 
 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 package codec
 
+import (
+	"reflect"
+	"sync/atomic"
+)
+
 // stringView returns a view of the []byte as a string.
 // In unsafe mode, it doesn't incur allocation and copying caused by conversion.
 // In regular safe mode, it is an allocation and copy.
+//
+// Usage: Always maintain a reference to v while result of this call is in use,
+//        and call keepAlive4BytesView(v) at point where done with view.
 func stringView(v []byte) string {
 	return string(v)
 }
@@ -15,6 +23,134 @@ func stringView(v []byte) string {
 // bytesView returns a view of the string as a []byte.
 // In unsafe mode, it doesn't incur allocation and copying caused by conversion.
 // In regular safe mode, it is an allocation and copy.
+//
+// Usage: Always maintain a reference to v while result of this call is in use,
+//        and call keepAlive4BytesView(v) at point where done with view.
 func bytesView(v string) []byte {
 	return []byte(v)
 }
+
+func definitelyNil(v interface{}) bool {
+	return false
+	// rv := reflect.ValueOf(v)
+	// switch rv.Kind() {
+	// case reflect.Invalid:
+	// 	return true
+	// case reflect.Ptr, reflect.Interface, reflect.Chan, reflect.Slice, reflect.Map, reflect.Func:
+	// 	return rv.IsNil()
+	// default:
+	// 	return false
+	// }
+}
+
+// // keepAlive4BytesView maintains a reference to the input parameter for bytesView.
+// //
+// // Usage: call this at point where done with the bytes view.
+// func keepAlive4BytesView(v string) {}
+
+// // keepAlive4BytesView maintains a reference to the input parameter for stringView.
+// //
+// // Usage: call this at point where done with the string view.
+// func keepAlive4StringView(v []byte) {}
+
+func rv2i(rv reflect.Value) interface{} {
+	return rv.Interface()
+}
+
+func rt2id(rt reflect.Type) uintptr {
+	return reflect.ValueOf(rt).Pointer()
+}
+
+func rv2rtid(rv reflect.Value) uintptr {
+	return reflect.ValueOf(rv.Type()).Pointer()
+}
+
+// --------------------------
+// type ptrToRvMap struct{}
+
+// func (_ *ptrToRvMap) init() {}
+// func (_ *ptrToRvMap) get(i interface{}) reflect.Value {
+// 	return reflect.ValueOf(i).Elem()
+// }
+
+// --------------------------
+type atomicTypeInfoSlice struct {
+	v atomic.Value
+}
+
+func (x *atomicTypeInfoSlice) load() *[]rtid2ti {
+	i := x.v.Load()
+	if i == nil {
+		return nil
+	}
+	return i.(*[]rtid2ti)
+}
+
+func (x *atomicTypeInfoSlice) store(p *[]rtid2ti) {
+	x.v.Store(p)
+}
+
+// --------------------------
+func (d *Decoder) raw(f *codecFnInfo, rv reflect.Value) {
+	rv.SetBytes(d.rawBytes())
+}
+
+func (d *Decoder) kString(f *codecFnInfo, rv reflect.Value) {
+	rv.SetString(d.d.DecodeString())
+}
+
+func (d *Decoder) kBool(f *codecFnInfo, rv reflect.Value) {
+	rv.SetBool(d.d.DecodeBool())
+}
+
+func (d *Decoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	rv.SetFloat(d.d.DecodeFloat(true))
+}
+
+func (d *Decoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
+	rv.SetFloat(d.d.DecodeFloat(false))
+}
+
+func (d *Decoder) kInt(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt(intBitsize))
+}
+
+func (d *Decoder) kInt8(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt(8))
+}
+
+func (d *Decoder) kInt16(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt(16))
+}
+
+func (d *Decoder) kInt32(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt(32))
+}
+
+func (d *Decoder) kInt64(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt(64))
+}
+
+func (d *Decoder) kUint(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(uintBitsize))
+}
+
+func (d *Decoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(uintBitsize))
+}
+
+func (d *Decoder) kUint8(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(8))
+}
+
+func (d *Decoder) kUint16(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(16))
+}
+
+func (d *Decoder) kUint32(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(32))
+}
+
+func (d *Decoder) kUint64(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(64))
+}
diff --git a/vendor/github.com/ugorji/go/codec/helper_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_unsafe.go
index 0f596c71aad..c7c01b811c1 100644
--- a/vendor/github.com/ugorji/go/codec/helper_unsafe.go
+++ b/vendor/github.com/ugorji/go/codec/helper_unsafe.go
@@ -1,4 +1,6 @@
-// +build unsafe
+// +build !safe
+// +build !appengine
+// +build go1.7
 
 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
@@ -6,10 +8,17 @@
 package codec
 
 import (
+	"reflect"
+	"sync/atomic"
 	"unsafe"
 )
 
 // This file has unsafe variants of some helper methods.
+// NOTE: See helper_not_unsafe.go for the usage information.
+
+// var zeroRTv [4]uintptr
+
+const unsafeFlagIndir = 1 << 7 // keep in sync with GO_ROOT/src/reflect/value.go
 
 type unsafeString struct {
 	Data uintptr
@@ -22,9 +31,17 @@ type unsafeSlice struct {
 	Cap  int
 }
 
-// stringView returns a view of the []byte as a string.
-// In unsafe mode, it doesn't incur allocation and copying caused by conversion.
-// In regular safe mode, it is an allocation and copy.
+type unsafeIntf struct {
+	typ  unsafe.Pointer
+	word unsafe.Pointer
+}
+
+type unsafeReflectValue struct {
+	typ  unsafe.Pointer
+	ptr  unsafe.Pointer
+	flag uintptr
+}
+
 func stringView(v []byte) string {
 	if len(v) == 0 {
 		return ""
@@ -35,9 +52,6 @@ func stringView(v []byte) string {
 	return *(*string)(unsafe.Pointer(&sx))
 }
 
-// bytesView returns a view of the string as a []byte.
-// In unsafe mode, it doesn't incur allocation and copying caused by conversion.
-// In regular safe mode, it is an allocation and copy.
 func bytesView(v string) []byte {
 	if len(v) == 0 {
 		return zeroByteSlice
@@ -47,3 +61,358 @@ func bytesView(v string) []byte {
 	bx := unsafeSlice{sx.Data, sx.Len, sx.Len}
 	return *(*[]byte)(unsafe.Pointer(&bx))
 }
+
+func definitelyNil(v interface{}) bool {
+	return (*unsafeIntf)(unsafe.Pointer(&v)).word == nil
+}
+
+// func keepAlive4BytesView(v string) {
+// 	runtime.KeepAlive(v)
+// }
+
+// func keepAlive4StringView(v []byte) {
+// 	runtime.KeepAlive(v)
+// }
+
+// TODO: consider a more generally-known optimization for reflect.Value ==> Interface
+//
+// Currently, we use this fragile method that taps into implememtation details from
+// the source go stdlib reflect/value.go,
+// and trims the implementation.
+func rv2i(rv reflect.Value) interface{} {
+	if false {
+		return rv.Interface()
+	}
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	// references that are single-words (map, ptr) may be double-referenced as flagIndir
+	kk := urv.flag & (1<<5 - 1)
+	if (kk == uintptr(reflect.Map) || kk == uintptr(reflect.Ptr)) && urv.flag&unsafeFlagIndir != 0 {
+		return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: *(*unsafe.Pointer)(urv.ptr), typ: urv.typ}))
+	}
+	return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: urv.ptr, typ: urv.typ}))
+}
+
+func rt2id(rt reflect.Type) uintptr {
+	return uintptr(((*unsafeIntf)(unsafe.Pointer(&rt))).word)
+}
+
+func rv2rtid(rv reflect.Value) uintptr {
+	return uintptr((*unsafeReflectValue)(unsafe.Pointer(&rv)).typ)
+}
+
+// func rv0t(rt reflect.Type) reflect.Value {
+// 	ut := (*unsafeIntf)(unsafe.Pointer(&rt))
+// 	// we need to determine whether ifaceIndir, and then whether to just pass 0 as the ptr
+// 	uv := unsafeReflectValue{ut.word, &zeroRTv, flag(rt.Kind())}
+// 	return *(*reflect.Value)(unsafe.Pointer(&uv})
+// }
+
+// --------------------------
+type atomicTypeInfoSlice struct {
+	v unsafe.Pointer
+}
+
+func (x *atomicTypeInfoSlice) load() *[]rtid2ti {
+	return (*[]rtid2ti)(atomic.LoadPointer(&x.v))
+}
+
+func (x *atomicTypeInfoSlice) store(p *[]rtid2ti) {
+	atomic.StorePointer(&x.v, unsafe.Pointer(p))
+}
+
+// --------------------------
+func (d *Decoder) raw(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	// if urv.flag&unsafeFlagIndir != 0 {
+	// 	urv.ptr = *(*unsafe.Pointer)(urv.ptr)
+	// }
+	*(*[]byte)(urv.ptr) = d.rawBytes()
+}
+
+func (d *Decoder) kString(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*string)(urv.ptr) = d.d.DecodeString()
+}
+
+func (d *Decoder) kBool(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*bool)(urv.ptr) = d.d.DecodeBool()
+}
+
+func (d *Decoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*float32)(urv.ptr) = float32(d.d.DecodeFloat(true))
+}
+
+func (d *Decoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*float64)(urv.ptr) = d.d.DecodeFloat(false)
+}
+
+func (d *Decoder) kInt(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*int)(urv.ptr) = int(d.d.DecodeInt(intBitsize))
+}
+
+func (d *Decoder) kInt8(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*int8)(urv.ptr) = int8(d.d.DecodeInt(8))
+}
+
+func (d *Decoder) kInt16(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*int16)(urv.ptr) = int16(d.d.DecodeInt(16))
+}
+
+func (d *Decoder) kInt32(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*int32)(urv.ptr) = int32(d.d.DecodeInt(32))
+}
+
+func (d *Decoder) kInt64(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*int64)(urv.ptr) = d.d.DecodeInt(64)
+}
+
+func (d *Decoder) kUint(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint)(urv.ptr) = uint(d.d.DecodeUint(uintBitsize))
+}
+
+func (d *Decoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uintptr)(urv.ptr) = uintptr(d.d.DecodeUint(uintBitsize))
+}
+
+func (d *Decoder) kUint8(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint8)(urv.ptr) = uint8(d.d.DecodeUint(8))
+}
+
+func (d *Decoder) kUint16(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint16)(urv.ptr) = uint16(d.d.DecodeUint(16))
+}
+
+func (d *Decoder) kUint32(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint32)(urv.ptr) = uint32(d.d.DecodeUint(32))
+}
+
+func (d *Decoder) kUint64(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint64)(urv.ptr) = d.d.DecodeUint(64)
+}
+
+// ------------
+
+// func rt2id(rt reflect.Type) uintptr {
+// 	return uintptr(((*unsafeIntf)(unsafe.Pointer(&rt))).word)
+// 	// var i interface{} = rt
+// 	// // ui := (*unsafeIntf)(unsafe.Pointer(&i))
+// 	// return ((*unsafeIntf)(unsafe.Pointer(&i))).word
+// }
+
+// func rv2i(rv reflect.Value) interface{} {
+// 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+// 	// non-reference type: already indir
+// 	// reference type: depend on flagIndir property ('cos maybe was double-referenced)
+// 	// const (unsafeRvFlagKindMask    = 1<<5 - 1 , unsafeRvFlagIndir       = 1 << 7 )
+// 	// rvk := reflect.Kind(urv.flag & (1<<5 - 1))
+// 	// if (rvk == reflect.Chan ||
+// 	// 	rvk == reflect.Func ||
+// 	// 	rvk == reflect.Interface ||
+// 	// 	rvk == reflect.Map ||
+// 	// 	rvk == reflect.Ptr ||
+// 	// 	rvk == reflect.UnsafePointer) && urv.flag&(1<<8) != 0 {
+// 	// 	fmt.Printf(">>>>> ---- double indirect reference: %v, %v\n", rvk, rv.Type())
+// 	// 	return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: *(*unsafe.Pointer)(urv.ptr), typ: urv.typ}))
+// 	// }
+// 	if urv.flag&(1<<5-1) == uintptr(reflect.Map) && urv.flag&(1<<7) != 0 {
+// 		// fmt.Printf(">>>>> ---- double indirect reference: %v, %v\n", rvk, rv.Type())
+// 		return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: *(*unsafe.Pointer)(urv.ptr), typ: urv.typ}))
+// 	}
+// 	// fmt.Printf(">>>>> ++++ direct reference: %v, %v\n", rvk, rv.Type())
+// 	return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: urv.ptr, typ: urv.typ}))
+// }
+
+// const (
+// 	unsafeRvFlagKindMask    = 1<<5 - 1
+// 	unsafeRvKindDirectIface = 1 << 5
+// 	unsafeRvFlagIndir       = 1 << 7
+// 	unsafeRvFlagAddr        = 1 << 8
+// 	unsafeRvFlagMethod      = 1 << 9
+
+// 	_USE_RV_INTERFACE bool = false
+// 	_UNSAFE_RV_DEBUG       = true
+// )
+
+// type unsafeRtype struct {
+// 	_    [2]uintptr
+// 	_    uint32
+// 	_    uint8
+// 	_    uint8
+// 	_    uint8
+// 	kind uint8
+// 	_    [2]uintptr
+// 	_    int32
+// }
+
+// func _rv2i(rv reflect.Value) interface{} {
+// 	// Note: From use,
+// 	//   - it's never an interface
+// 	//   - the only calls here are for ifaceIndir types.
+// 	//     (though that conditional is wrong)
+// 	//     To know for sure, we need the value of t.kind (which is not exposed).
+// 	//
+// 	// Need to validate the path: type is indirect ==> only value is indirect ==> default (value is direct)
+// 	//    - Type indirect, Value indirect: ==> numbers, boolean, slice, struct, array, string
+// 	//    - Type Direct,   Value indirect: ==> map???
+// 	//    - Type Direct,   Value direct:   ==> pointers, unsafe.Pointer, func, chan, map
+// 	//
+// 	// TRANSLATES TO:
+// 	//    if typeIndirect { } else if valueIndirect { } else { }
+// 	//
+// 	// Since we don't deal with funcs, then "flagNethod" is unset, and can be ignored.
+
+// 	if _USE_RV_INTERFACE {
+// 		return rv.Interface()
+// 	}
+// 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+
+// 	// if urv.flag&unsafeRvFlagMethod != 0 || urv.flag&unsafeRvFlagKindMask == uintptr(reflect.Interface) {
+// 	// 	println("***** IS flag method or interface: delegating to rv.Interface()")
+// 	// 	return rv.Interface()
+// 	// }
+
+// 	// if urv.flag&unsafeRvFlagKindMask == uintptr(reflect.Interface) {
+// 	// 	println("***** IS Interface: delegate to rv.Interface")
+// 	// 	return rv.Interface()
+// 	// }
+// 	// if urv.flag&unsafeRvFlagKindMask&unsafeRvKindDirectIface == 0 {
+// 	// 	if urv.flag&unsafeRvFlagAddr == 0 {
+// 	// 		println("***** IS ifaceIndir typ")
+// 	// 		// ui := unsafeIntf{word: urv.ptr, typ: urv.typ}
+// 	// 		// return *(*interface{})(unsafe.Pointer(&ui))
+// 	// 		// return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: urv.ptr, typ: urv.typ}))
+// 	// 	}
+// 	// } else if urv.flag&unsafeRvFlagIndir != 0 {
+// 	// 	println("***** IS flagindir")
+// 	// 	// return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: *(*unsafe.Pointer)(urv.ptr), typ: urv.typ}))
+// 	// } else {
+// 	// 	println("***** NOT flagindir")
+// 	// 	return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: urv.ptr, typ: urv.typ}))
+// 	// }
+// 	// println("***** default: delegate to rv.Interface")
+
+// 	urt := (*unsafeRtype)(unsafe.Pointer(urv.typ))
+// 	if _UNSAFE_RV_DEBUG {
+// 		fmt.Printf(">>>> start: %v: ", rv.Type())
+// 		fmt.Printf("%v - %v\n", *urv, *urt)
+// 	}
+// 	if urt.kind&unsafeRvKindDirectIface == 0 {
+// 		if _UNSAFE_RV_DEBUG {
+// 			fmt.Printf("**** +ifaceIndir type: %v\n", rv.Type())
+// 		}
+// 		// println("***** IS ifaceIndir typ")
+// 		// if true || urv.flag&unsafeRvFlagAddr == 0 {
+// 		// 	// println("    ***** IS NOT addr")
+// 		return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: urv.ptr, typ: urv.typ}))
+// 		// }
+// 	} else if urv.flag&unsafeRvFlagIndir != 0 {
+// 		if _UNSAFE_RV_DEBUG {
+// 			fmt.Printf("**** +flagIndir type: %v\n", rv.Type())
+// 		}
+// 		// println("***** IS flagindir")
+// 		return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: *(*unsafe.Pointer)(urv.ptr), typ: urv.typ}))
+// 	} else {
+// 		if _UNSAFE_RV_DEBUG {
+// 			fmt.Printf("**** -flagIndir type: %v\n", rv.Type())
+// 		}
+// 		// println("***** NOT flagindir")
+// 		return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: urv.ptr, typ: urv.typ}))
+// 	}
+// 	// println("***** default: delegating to rv.Interface()")
+// 	// return rv.Interface()
+// }
+
+// var staticM0 = make(map[string]uint64)
+// var staticI0 = (int32)(-5)
+
+// func staticRv2iTest() {
+// 	i0 := (int32)(-5)
+// 	m0 := make(map[string]uint16)
+// 	m0["1"] = 1
+// 	for _, i := range []interface{}{
+// 		(int)(7),
+// 		(uint)(8),
+// 		(int16)(-9),
+// 		(uint16)(19),
+// 		(uintptr)(77),
+// 		(bool)(true),
+// 		float32(-32.7),
+// 		float64(64.9),
+// 		complex(float32(19), 5),
+// 		complex(float64(-32), 7),
+// 		[4]uint64{1, 2, 3, 4},
+// 		(chan<- int)(nil), // chan,
+// 		rv2i,              // func
+// 		io.Writer(ioutil.Discard),
+// 		make(map[string]uint),
+// 		(map[string]uint)(nil),
+// 		staticM0,
+// 		m0,
+// 		&m0,
+// 		i0,
+// 		&i0,
+// 		&staticI0,
+// 		&staticM0,
+// 		[]uint32{6, 7, 8},
+// 		"abc",
+// 		Raw{},
+// 		RawExt{},
+// 		&Raw{},
+// 		&RawExt{},
+// 		unsafe.Pointer(&i0),
+// 	} {
+// 		i2 := rv2i(reflect.ValueOf(i))
+// 		eq := reflect.DeepEqual(i, i2)
+// 		fmt.Printf(">>>> %v == %v? %v\n", i, i2, eq)
+// 	}
+// 	// os.Exit(0)
+// }
+
+// func init() {
+// 	staticRv2iTest()
+// }
+
+// func rv2i(rv reflect.Value) interface{} {
+// 	if _USE_RV_INTERFACE || rv.Kind() == reflect.Interface || rv.CanAddr() {
+// 		return rv.Interface()
+// 	}
+// 	// var i interface{}
+// 	// ui := (*unsafeIntf)(unsafe.Pointer(&i))
+// 	var ui unsafeIntf
+// 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+// 	// fmt.Printf("urv: flag: %b, typ: %b, ptr: %b\n", urv.flag, uintptr(urv.typ), uintptr(urv.ptr))
+// 	if (urv.flag&unsafeRvFlagKindMask)&unsafeRvKindDirectIface == 0 {
+// 		if urv.flag&unsafeRvFlagAddr != 0 {
+// 			println("***** indirect and addressable! Needs typed move - delegate to rv.Interface()")
+// 			return rv.Interface()
+// 		}
+// 		println("****** indirect type/kind")
+// 		ui.word = urv.ptr
+// 	} else if urv.flag&unsafeRvFlagIndir != 0 {
+// 		println("****** unsafe rv flag indir")
+// 		ui.word = *(*unsafe.Pointer)(urv.ptr)
+// 	} else {
+// 		println("****** default: assign prt to word directly")
+// 		ui.word = urv.ptr
+// 	}
+// 	// ui.word = urv.ptr
+// 	ui.typ = urv.typ
+// 	// fmt.Printf("(pointers) ui.typ: %p, word: %p\n", ui.typ, ui.word)
+// 	// fmt.Printf("(binary)   ui.typ: %b, word: %b\n", uintptr(ui.typ), uintptr(ui.word))
+// 	return *(*interface{})(unsafe.Pointer(&ui))
+// 	// return i
+// }
diff --git a/vendor/github.com/ugorji/go/codec/json.go b/vendor/github.com/ugorji/go/codec/json.go
index 5bb38962897..a6af2c809b0 100644
--- a/vendor/github.com/ugorji/go/codec/json.go
+++ b/vendor/github.com/ugorji/go/codec/json.go
@@ -34,7 +34,6 @@ package codec
 import (
 	"bytes"
 	"encoding/base64"
-	"fmt"
 	"reflect"
 	"strconv"
 	"unicode/utf16"
@@ -44,21 +43,29 @@ import (
 //--------------------------------
 
 var (
-	jsonLiterals = [...]byte{'t', 'r', 'u', 'e', 'f', 'a', 'l', 's', 'e', 'n', 'u', 'l', 'l'}
+	// jsonLiterals = [...]byte{'t', 'r', 'u', 'e', 'f', 'a', 'l', 's', 'e', 'n', 'u', 'l', 'l'}
 
-	jsonFloat64Pow10 = [...]float64{
-		1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
-		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
-		1e20, 1e21, 1e22,
-	}
+	// jsonFloat64Pow10 = [...]float64{
+	// 	1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+	// 	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+	// 	1e20, 1e21, 1e22,
+	// }
 
-	jsonUint64Pow10 = [...]uint64{
-		1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
-		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
-	}
+	// jsonUint64Pow10 = [...]uint64{
+	// 	1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+	// 	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+	// }
 
 	// jsonTabs and jsonSpaces are used as caches for indents
 	jsonTabs, jsonSpaces string
+
+	jsonCharHtmlSafeSet   bitset128
+	jsonCharSafeSet       bitset128
+	jsonCharWhitespaceSet bitset256
+	jsonNumSet            bitset256
+	// jsonIsFloatSet        bitset256
+
+	jsonU4Set [256]byte
 )
 
 const (
@@ -78,20 +85,9 @@ const (
 	// P.S. Do not expect a significant decoding boost from this.
 	jsonValidateSymbols = true
 
-	// if jsonTruncateMantissa, truncate mantissa if trailing 0's.
-	// This is important because it could allow some floats to be decoded without
-	// deferring to strconv.ParseFloat.
-	jsonTruncateMantissa = true
-
-	// if mantissa >= jsonNumUintCutoff before multiplying by 10, this is an overflow
-	jsonNumUintCutoff = (1<<64-1)/uint64(10) + 1 // cutoff64(base)
-
-	// if mantissa >= jsonNumUintMaxVal, this is an overflow
-	jsonNumUintMaxVal = 1<<uint64(64) - 1
-
-	// jsonNumDigitsUint64Largest = 19
-
 	jsonSpacesOrTabsLen = 128
+
+	jsonU4SetErrVal = 128
 )
 
 func init() {
@@ -105,6 +101,46 @@ func init() {
 		bs[i] = '\t'
 	}
 	jsonTabs = string(bs[:])
+
+	// populate the safe values as true: note: ASCII control characters are (0-31)
+	// jsonCharSafeSet:     all true except (0-31) " \
+	// jsonCharHtmlSafeSet: all true except (0-31) " \ < > &
+	var i byte
+	for i = 32; i < utf8.RuneSelf; i++ {
+		switch i {
+		case '"', '\\':
+		case '<', '>', '&':
+			jsonCharSafeSet.set(i) // = true
+		default:
+			jsonCharSafeSet.set(i)
+			jsonCharHtmlSafeSet.set(i)
+		}
+	}
+	for i = 0; i <= utf8.RuneSelf; i++ {
+		switch i {
+		case ' ', '\t', '\r', '\n':
+			jsonCharWhitespaceSet.set(i)
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'e', 'E', '.', '+', '-':
+			jsonNumSet.set(i)
+		}
+	}
+	for j := range jsonU4Set {
+		switch i = byte(j); i {
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			jsonU4Set[i] = i - '0'
+		case 'a', 'b', 'c', 'd', 'e', 'f':
+			jsonU4Set[i] = i - 'a' + 10
+		case 'A', 'B', 'C', 'D', 'E', 'F':
+			jsonU4Set[i] = i - 'A' + 10
+		default:
+			jsonU4Set[i] = jsonU4SetErrVal
+		}
+		// switch i = byte(j); i {
+		// case 'e', 'E', '.':
+		// 	jsonIsFloatSet.set(i)
+		// }
+	}
+	// jsonU4Set[255] = jsonU4SetErrVal
 }
 
 type jsonEncDriver struct {
@@ -127,48 +163,116 @@ type jsonEncDriver struct {
 //   - newline and indent are added before each ending,
 //     except there was no entry (so we can have {} or [])
 
-func (e *jsonEncDriver) sendContainerState(c containerState) {
-	// determine whether to output separators
-	if c == containerMapKey {
-		if e.c != containerMapStart {
-			e.w.writen1(',')
-		}
-		if e.d {
-			e.writeIndent()
-		}
-	} else if c == containerMapValue {
-		if e.d {
-			e.w.writen2(':', ' ')
-		} else {
-			e.w.writen1(':')
-		}
-	} else if c == containerMapEnd {
-		if e.d {
-			e.dl--
-			if e.c != containerMapStart {
-				e.writeIndent()
-			}
-		}
-		e.w.writen1('}')
-	} else if c == containerArrayElem {
-		if e.c != containerArrayStart {
-			e.w.writen1(',')
-		}
-		if e.d {
-			e.writeIndent()
-		}
-	} else if c == containerArrayEnd {
-		if e.d {
-			e.dl--
-			if e.c != containerArrayStart {
-				e.writeIndent()
-			}
-		}
-		e.w.writen1(']')
+func (e *jsonEncDriver) WriteArrayStart(length int) {
+	if e.d {
+		e.dl++
 	}
-	e.c = c
+	e.w.writen1('[')
+	e.c = containerArrayStart
 }
 
+func (e *jsonEncDriver) WriteArrayElem() {
+	if e.c != containerArrayStart {
+		e.w.writen1(',')
+	}
+	if e.d {
+		e.writeIndent()
+	}
+	e.c = containerArrayElem
+}
+
+func (e *jsonEncDriver) WriteArrayEnd() {
+	if e.d {
+		e.dl--
+		if e.c != containerArrayStart {
+			e.writeIndent()
+		}
+	}
+	e.w.writen1(']')
+	e.c = containerArrayEnd
+}
+
+func (e *jsonEncDriver) WriteMapStart(length int) {
+	if e.d {
+		e.dl++
+	}
+	e.w.writen1('{')
+	e.c = containerMapStart
+}
+
+func (e *jsonEncDriver) WriteMapElemKey() {
+	if e.c != containerMapStart {
+		e.w.writen1(',')
+	}
+	if e.d {
+		e.writeIndent()
+	}
+	e.c = containerMapKey
+}
+
+func (e *jsonEncDriver) WriteMapElemValue() {
+	if e.d {
+		e.w.writen2(':', ' ')
+	} else {
+		e.w.writen1(':')
+	}
+	e.c = containerMapValue
+}
+
+func (e *jsonEncDriver) WriteMapEnd() {
+	if e.d {
+		e.dl--
+		if e.c != containerMapStart {
+			e.writeIndent()
+		}
+	}
+	e.w.writen1('}')
+	e.c = containerMapEnd
+}
+
+// func (e *jsonEncDriver) sendContainerState(c containerState) {
+// 	// determine whether to output separators
+// 	switch c {
+// 	case containerMapKey:
+// 		if e.c != containerMapStart {
+// 			e.w.writen1(',')
+// 		}
+// 		if e.d {
+// 			e.writeIndent()
+// 		}
+// 	case containerMapValue:
+// 		if e.d {
+// 			e.w.writen2(':', ' ')
+// 		} else {
+// 			e.w.writen1(':')
+// 		}
+// 	case containerMapEnd:
+// 		if e.d {
+// 			e.dl--
+// 			if e.c != containerMapStart {
+// 				e.writeIndent()
+// 			}
+// 		}
+// 		e.w.writen1('}')
+// 	case containerArrayElem:
+// 		if e.c != containerArrayStart {
+// 			e.w.writen1(',')
+// 		}
+// 		if e.d {
+// 			e.writeIndent()
+// 		}
+// 	case containerArrayEnd:
+// 		if e.d {
+// 			e.dl--
+// 			if e.c != containerArrayStart {
+// 				e.writeIndent()
+// 			}
+// 		}
+// 		e.w.writen1(']')
+// 	}
+// 	e.c = c
+// }
+
 func (e *jsonEncDriver) writeIndent() {
 	e.w.writen1('\n')
 	if x := len(e.ds) * int(e.dl); x <= jsonSpacesOrTabsLen {
@@ -185,14 +289,14 @@ func (e *jsonEncDriver) writeIndent() {
 }
 
 func (e *jsonEncDriver) EncodeNil() {
-	e.w.writeb(jsonLiterals[9:13]) // null
+	e.w.writen4('n', 'u', 'l', 'l') // e.w.writeb(jsonLiterals[9:13]) // null
 }
 
 func (e *jsonEncDriver) EncodeBool(b bool) {
 	if b {
-		e.w.writeb(jsonLiterals[0:4]) // true
+		e.w.writen4('t', 'r', 'u', 'e') // e.w.writeb(jsonLiterals[0:4]) // true
 	} else {
-		e.w.writeb(jsonLiterals[4:9]) // false
+		e.w.writen5('f', 'a', 'l', 's', 'e') // e.w.writeb(jsonLiterals[4:9]) // false
 	}
 }
 
@@ -201,16 +305,16 @@ func (e *jsonEncDriver) EncodeFloat32(f float32) {
 }
 
 func (e *jsonEncDriver) EncodeFloat64(f float64) {
-	// e.w.writestr(strconv.FormatFloat(f, 'E', -1, 64))
 	e.encodeFloat(f, 64)
 }
 
 func (e *jsonEncDriver) encodeFloat(f float64, numbits int) {
 	x := strconv.AppendFloat(e.b[:0], f, 'G', -1, numbits)
-	e.w.writeb(x)
-	if bytes.IndexByte(x, 'E') == -1 && bytes.IndexByte(x, '.') == -1 {
-		e.w.writen2('.', '0')
+	// if bytes.IndexByte(x, 'E') == -1 && bytes.IndexByte(x, '.') == -1 {
+	if !jsonIsFloatBytesB2(x) {
+		x = append(x, '.', '0')
 	}
+	e.w.writeb(x)
 }
 
 func (e *jsonEncDriver) EncodeInt(v int64) {
@@ -235,7 +339,7 @@ func (e *jsonEncDriver) EncodeUint(v uint64) {
 
 func (e *jsonEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Encoder) {
 	if v := ext.ConvertExt(rv); v == nil {
-		e.w.writeb(jsonLiterals[9:13]) // null // e.EncodeNil()
+		e.w.writen4('n', 'u', 'l', 'l') // e.w.writeb(jsonLiterals[9:13]) // null // e.EncodeNil()
 	} else {
 		en.encode(v)
 	}
@@ -244,35 +348,17 @@ func (e *jsonEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Enco
 func (e *jsonEncDriver) EncodeRawExt(re *RawExt, en *Encoder) {
 	// only encodes re.Value (never re.Data)
 	if re.Value == nil {
-		e.w.writeb(jsonLiterals[9:13]) // null // e.EncodeNil()
+		e.w.writen4('n', 'u', 'l', 'l') // e.w.writeb(jsonLiterals[9:13]) // null // e.EncodeNil()
 	} else {
 		en.encode(re.Value)
 	}
 }
 
-func (e *jsonEncDriver) EncodeArrayStart(length int) {
-	if e.d {
-		e.dl++
-	}
-	e.w.writen1('[')
-	e.c = containerArrayStart
-}
-
-func (e *jsonEncDriver) EncodeMapStart(length int) {
-	if e.d {
-		e.dl++
-	}
-	e.w.writen1('{')
-	e.c = containerMapStart
-}
-
 func (e *jsonEncDriver) EncodeString(c charEncoding, v string) {
-	// e.w.writestr(strconv.Quote(v))
 	e.quoteStr(v)
 }
 
 func (e *jsonEncDriver) EncodeSymbol(v string) {
-	// e.EncodeString(c_UTF8, v)
 	e.quoteStr(v)
 }
 
@@ -294,7 +380,6 @@ func (e *jsonEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
 		e.w.writeb(e.bs)
 		e.w.writen1('"')
 	} else {
-		// e.EncodeString(c, string(v))
 		e.quoteStr(stringView(v))
 	}
 }
@@ -308,10 +393,13 @@ func (e *jsonEncDriver) quoteStr(s string) {
 	const hex = "0123456789abcdef"
 	w := e.w
 	w.writen1('"')
-	start := 0
-	for i := 0; i < len(s); {
+	var start int
+	for i, slen := 0, len(s); i < slen; {
+		// encode all bytes < 0x20 (except \r, \n).
+		// also encode < > & to prevent security holes when served to some browsers.
 		if b := s[i]; b < utf8.RuneSelf {
-			if 0x20 <= b && b != '\\' && b != '"' && b != '<' && b != '>' && b != '&' {
+			// if 0x20 <= b && b != '\\' && b != '"' && b != '<' && b != '>' && b != '&' {
+			if jsonCharHtmlSafeSet.isset(b) || (e.h.HTMLCharsAsIs && jsonCharSafeSet.isset(b)) {
 				i++
 				continue
 			}
@@ -332,8 +420,6 @@ func (e *jsonEncDriver) quoteStr(s string) {
 			case '\t':
 				w.writen2('\\', 't')
 			default:
-				// encode all bytes < 0x20 (except \r, \n).
-				// also encode < > & to prevent security holes when served to some browsers.
 				w.writestr(`\u00`)
 				w.writen2(hex[b>>4], hex[b&0xF])
 			}
@@ -352,7 +438,7 @@ func (e *jsonEncDriver) quoteStr(s string) {
 			continue
 		}
 		// U+2028 is LINE SEPARATOR. U+2029 is PARAGRAPH SEPARATOR.
-		// Both technically valid JSON, but bomb on JSONP, so fix here.
+		// Both technically valid JSON, but bomb on JSONP, so fix here unconditionally.
 		if c == '\u2028' || c == '\u2029' {
 			if start < i {
 				w.writestr(s[start:i])
@@ -371,86 +457,14 @@ func (e *jsonEncDriver) quoteStr(s string) {
 	w.writen1('"')
 }
 
-//--------------------------------
-
-type jsonNum struct {
-	// bytes            []byte // may have [+-.eE0-9]
-	mantissa         uint64 // where mantissa ends, and maybe dot begins.
-	exponent         int16  // exponent value.
-	manOverflow      bool
-	neg              bool // started with -. No initial sign in the bytes above.
-	dot              bool // has dot
-	explicitExponent bool // explicit exponent
-}
-
-func (x *jsonNum) reset() {
-	x.manOverflow = false
-	x.neg = false
-	x.dot = false
-	x.explicitExponent = false
-	x.mantissa = 0
-	x.exponent = 0
-}
-
-// uintExp is called only if exponent > 0.
-func (x *jsonNum) uintExp() (n uint64, overflow bool) {
-	n = x.mantissa
-	e := x.exponent
-	if e >= int16(len(jsonUint64Pow10)) {
-		overflow = true
-		return
+func (e *jsonEncDriver) atEndOfEncode() {
+	if e.h.TermWhitespace {
+		if e.d {
+			e.w.writen1('\n')
+		} else {
+			e.w.writen1(' ')
+		}
 	}
-	n *= jsonUint64Pow10[e]
-	if n < x.mantissa || n > jsonNumUintMaxVal {
-		overflow = true
-		return
-	}
-	return
-	// for i := int16(0); i < e; i++ {
-	// 	if n >= jsonNumUintCutoff {
-	// 		overflow = true
-	// 		return
-	// 	}
-	// 	n *= 10
-	// }
-	// return
-}
-
-// these constants are only used withn floatVal.
-// They are brought out, so that floatVal can be inlined.
-const (
-	jsonUint64MantissaBits = 52
-	jsonMaxExponent        = int16(len(jsonFloat64Pow10)) - 1
-)
-
-func (x *jsonNum) floatVal() (f float64, parseUsingStrConv bool) {
-	// We do not want to lose precision.
-	// Consequently, we will delegate to strconv.ParseFloat if any of the following happen:
-	//    - There are more digits than in math.MaxUint64: 18446744073709551615 (20 digits)
-	//      We expect up to 99.... (19 digits)
-	//    - The mantissa cannot fit into a 52 bits of uint64
-	//    - The exponent is beyond our scope ie beyong 22.
-	parseUsingStrConv = x.manOverflow ||
-		x.exponent > jsonMaxExponent ||
-		(x.exponent < 0 && -(x.exponent) > jsonMaxExponent) ||
-		x.mantissa>>jsonUint64MantissaBits != 0
-
-	if parseUsingStrConv {
-		return
-	}
-
-	// all good. so handle parse here.
-	f = float64(x.mantissa)
-	// fmt.Printf(".Float: uint64 value: %v, float: %v\n", m, f)
-	if x.neg {
-		f = -f
-	}
-	if x.exponent > 0 {
-		f *= jsonFloat64Pow10[x.exponent]
-	} else if x.exponent < 0 {
-		f /= jsonFloat64Pow10[-x.exponent]
-	}
-	return
 }
 
 type jsonDecDriver struct {
@@ -463,6 +477,8 @@ type jsonDecDriver struct {
 	// tok is used to store the token read right after skipWhiteSpace.
 	tok uint8
 
+	fnull bool // found null from appendStringAsBytes
+
 	bstr [8]byte  // scratch used for string \UXXX parsing
 	b    [64]byte // scratch, used for parsing strings or numbers
 	b2   [64]byte // scratch, used only for decodeBytes (after base64)
@@ -470,26 +486,14 @@ type jsonDecDriver struct {
 
 	se setExtWrapper
 
-	n jsonNum
+	// n jsonNum
 }
 
 func jsonIsWS(b byte) bool {
-	return b == ' ' || b == '\t' || b == '\r' || b == '\n'
+	// return b == ' ' || b == '\t' || b == '\r' || b == '\n'
+	return jsonCharWhitespaceSet.isset(b)
 }
 
-// // This will skip whitespace characters and return the next byte to read.
-// // The next byte determines what the value will be one of.
-// func (d *jsonDecDriver) skipWhitespace() {
-// 	// fast-path: do not enter loop. Just check first (in case no whitespace).
-// 	b := d.r.readn1()
-// 	if jsonIsWS(b) {
-// 		r := d.r
-// 		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-// 		}
-// 	}
-// 	d.tok = b
-// }
-
 func (d *jsonDecDriver) uncacheRead() {
 	if d.tok != 0 {
 		d.r.unreadn1()
@@ -497,107 +501,9 @@ func (d *jsonDecDriver) uncacheRead() {
 	}
 }
 
-func (d *jsonDecDriver) sendContainerState(c containerState) {
-	if d.tok == 0 {
-		var b byte
-		r := d.r
-		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-		}
-		d.tok = b
-	}
-	var xc uint8 // char expected
-	if c == containerMapKey {
-		if d.c != containerMapStart {
-			xc = ','
-		}
-	} else if c == containerMapValue {
-		xc = ':'
-	} else if c == containerMapEnd {
-		xc = '}'
-	} else if c == containerArrayElem {
-		if d.c != containerArrayStart {
-			xc = ','
-		}
-	} else if c == containerArrayEnd {
-		xc = ']'
-	}
-	if xc != 0 {
-		if d.tok != xc {
-			d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
-		}
-		d.tok = 0
-	}
-	d.c = c
-}
-
-func (d *jsonDecDriver) CheckBreak() bool {
-	if d.tok == 0 {
-		var b byte
-		r := d.r
-		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-		}
-		d.tok = b
-	}
-	if d.tok == '}' || d.tok == ']' {
-		// d.tok = 0 // only checking, not consuming
-		return true
-	}
-	return false
-}
-
-func (d *jsonDecDriver) readStrIdx(fromIdx, toIdx uint8) {
-	bs := d.r.readx(int(toIdx - fromIdx))
-	d.tok = 0
-	if jsonValidateSymbols {
-		if !bytes.Equal(bs, jsonLiterals[fromIdx:toIdx]) {
-			d.d.errorf("json: expecting %s: got %s", jsonLiterals[fromIdx:toIdx], bs)
-			return
-		}
-	}
-}
-
-func (d *jsonDecDriver) TryDecodeAsNil() bool {
-	if d.tok == 0 {
-		var b byte
-		r := d.r
-		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-		}
-		d.tok = b
-	}
-	if d.tok == 'n' {
-		d.readStrIdx(10, 13) // ull
-		return true
-	}
-	return false
-}
-
-func (d *jsonDecDriver) DecodeBool() bool {
-	if d.tok == 0 {
-		var b byte
-		r := d.r
-		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-		}
-		d.tok = b
-	}
-	if d.tok == 'f' {
-		d.readStrIdx(5, 9) // alse
-		return false
-	}
-	if d.tok == 't' {
-		d.readStrIdx(1, 4) // rue
-		return true
-	}
-	d.d.errorf("json: decode bool: got first char %c", d.tok)
-	return false // "unreachable"
-}
-
 func (d *jsonDecDriver) ReadMapStart() int {
 	if d.tok == 0 {
-		var b byte
-		r := d.r
-		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-		}
-		d.tok = b
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
 	}
 	if d.tok != '{' {
 		d.d.errorf("json: expect char '%c' but got char '%c'", '{', d.tok)
@@ -609,11 +515,7 @@ func (d *jsonDecDriver) ReadMapStart() int {
 
 func (d *jsonDecDriver) ReadArrayStart() int {
 	if d.tok == 0 {
-		var b byte
-		r := d.r
-		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-		}
-		d.tok = b
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
 	}
 	if d.tok != '[' {
 		d.d.errorf("json: expect char '%c' but got char '%c'", '[', d.tok)
@@ -623,14 +525,178 @@ func (d *jsonDecDriver) ReadArrayStart() int {
 	return -1
 }
 
+func (d *jsonDecDriver) CheckBreak() bool {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	return d.tok == '}' || d.tok == ']'
+}
+
+func (d *jsonDecDriver) ReadArrayElem() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.c != containerArrayStart {
+		const xc uint8 = ','
+		if d.tok != xc {
+			d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+		}
+		d.tok = 0
+	}
+	d.c = containerArrayElem
+}
+
+func (d *jsonDecDriver) ReadArrayEnd() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	const xc uint8 = ']'
+	if d.tok != xc {
+		d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+	}
+	d.tok = 0
+	d.c = containerArrayEnd
+}
+
+func (d *jsonDecDriver) ReadMapElemKey() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.c != containerMapStart {
+		const xc uint8 = ','
+		if d.tok != xc {
+			d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+		}
+		d.tok = 0
+	}
+	d.c = containerMapKey
+}
+
+func (d *jsonDecDriver) ReadMapElemValue() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	const xc uint8 = ':'
+	if d.tok != xc {
+		d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+	}
+	d.tok = 0
+	d.c = containerMapValue
+}
+
+func (d *jsonDecDriver) ReadMapEnd() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	const xc uint8 = '}'
+	if d.tok != xc {
+		d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+	}
+	d.tok = 0
+	d.c = containerMapEnd
+}
+
+// func (d *jsonDecDriver) readContainerState(c containerState, xc uint8, check bool) {
+// 	if d.tok == 0 {
+// 		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+// 	}
+// 	if check {
+// 		if d.tok != xc {
+// 			d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+// 		}
+// 		d.tok = 0
+// 	}
+// 	d.c = c
+// }
+
+// func (d *jsonDecDriver) sendContainerState(c containerState) {
+// 	if d.tok == 0 {
+// 		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+// 	}
+// 	var xc uint8 // char expected
+// 	switch c {
+// 	case containerMapKey:
+// 		if d.c != containerMapStart {
+// 			xc = ','
+// 		}
+// 	case containerMapValue:
+// 		xc = ':'
+// 	case containerMapEnd:
+// 		xc = '}'
+// 	case containerArrayElem:
+// 		if d.c != containerArrayStart {
+// 			xc = ','
+// 		}
+// 	case containerArrayEnd:
+// 		xc = ']'
+// 	}
+// 	if xc != 0 {
+// 		if d.tok != xc {
+// 			d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+// 		}
+// 		d.tok = 0
+// 	}
+// 	d.c = c
+// }
+
+// func (d *jsonDecDriver) readLiteralIdx(fromIdx, toIdx uint8) {
+// 	bs := d.r.readx(int(toIdx - fromIdx))
+// 	d.tok = 0
+// 	if jsonValidateSymbols && !bytes.Equal(bs, jsonLiterals[fromIdx:toIdx]) {
+// 		d.d.errorf("json: expecting %s: got %s", jsonLiterals[fromIdx:toIdx], bs)
+// 		return
+// 	}
+// }
+
+func (d *jsonDecDriver) readSymbol3(v1, v2, v3 uint8) {
+	b1, b2, b3 := d.r.readn3()
+	d.tok = 0
+	if jsonValidateSymbols && (b1 != v1 || b2 != v2 || b3 != v3) {
+		d.d.errorf("json: expecting %c, %c, %c: got %c, %c, %c", b1, b2, b3, v1, v2, v3)
+		return
+	}
+}
+
+func (d *jsonDecDriver) readSymbol4(v1, v2, v3, v4 uint8) {
+	b1, b2, b3, b4 := d.r.readn4()
+	d.tok = 0
+	if jsonValidateSymbols && (b1 != v1 || b2 != v2 || b3 != v3 || b4 != v4) {
+		d.d.errorf("json: expecting %c, %c, %c, %c: got %c, %c, %c, %c", b1, b2, b3, b4, v1, v2, v3, v4)
+		return
+	}
+}
+
+func (d *jsonDecDriver) TryDecodeAsNil() bool {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.tok == 'n' {
+		d.readSymbol3('u', 'l', 'l') // d.readLiteralIdx(10, 13) // ull
+		return true
+	}
+	return false
+}
+
+func (d *jsonDecDriver) DecodeBool() bool {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.tok == 'f' {
+		d.readSymbol4('a', 'l', 's', 'e') // d.readLiteralIdx(5, 9) // alse
+		return false
+	}
+	if d.tok == 't' {
+		d.readSymbol3('r', 'u', 'e') // d.readLiteralIdx(1, 4) // rue
+		return true
+	}
+	d.d.errorf("json: decode bool: got first char %c", d.tok)
+	return false // "unreachable"
+}
+
 func (d *jsonDecDriver) ContainerType() (vt valueType) {
 	// check container type by checking the first char
 	if d.tok == 0 {
-		var b byte
-		r := d.r
-		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-		}
-		d.tok = b
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
 	}
 	if b := d.tok; b == '{' {
 		return valueTypeMap
@@ -646,260 +712,51 @@ func (d *jsonDecDriver) ContainerType() (vt valueType) {
 	// return false // "unreachable"
 }
 
-func (d *jsonDecDriver) decNum(storeBytes bool) {
-	// If it is has a . or an e|E, decode as a float; else decode as an int.
+func (d *jsonDecDriver) decNumBytes() (bs []byte) {
+	// stores num bytes in d.bs
 	if d.tok == 0 {
-		var b byte
-		r := d.r
-		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-		}
-		d.tok = b
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
 	}
-	b := d.tok
-	var str bool
-	if b == '"' {
-		str = true
-		b = d.r.readn1()
-	}
-	if !(b == '+' || b == '-' || b == '.' || (b >= '0' && b <= '9')) {
-		d.d.errorf("json: decNum: got first char '%c'", b)
-		return
+	if d.tok == '"' {
+		bs = d.r.readUntil(d.b2[:0], '"')
+		bs = bs[:len(bs)-1]
+	} else {
+		d.r.unreadn1()
+		bs = d.r.readTo(d.bs[:0], &jsonNumSet)
 	}
 	d.tok = 0
+	return bs
+}
 
-	const cutoff = (1<<64-1)/uint64(10) + 1 // cutoff64(base)
-	const jsonNumUintMaxVal = 1<<uint64(64) - 1
-
-	n := &d.n
-	r := d.r
-	n.reset()
-	d.bs = d.bs[:0]
-
-	if str && storeBytes {
-		d.bs = append(d.bs, '"')
+func (d *jsonDecDriver) DecodeUint(bitsize uint8) (u uint64) {
+	bs := d.decNumBytes()
+	u, err := strconv.ParseUint(stringView(bs), 10, int(bitsize))
+	if err != nil {
+		d.d.errorf("json: decode uint from %s: %v", bs, err)
+		return
 	}
-
-	// The format of a number is as below:
-	// parsing:     sign? digit* dot? digit* e?  sign? digit*
-	// states:  0   1*    2      3*   4      5*  6     7
-	// We honor this state so we can break correctly.
-	var state uint8 = 0
-	var eNeg bool
-	var e int16
-	var eof bool
-LOOP:
-	for !eof {
-		// fmt.Printf("LOOP: b: %q\n", b)
-		switch b {
-		case '+':
-			switch state {
-			case 0:
-				state = 2
-				// do not add sign to the slice ...
-				b, eof = r.readn1eof()
-				continue
-			case 6: // typ = jsonNumFloat
-				state = 7
-			default:
-				break LOOP
-			}
-		case '-':
-			switch state {
-			case 0:
-				state = 2
-				n.neg = true
-				// do not add sign to the slice ...
-				b, eof = r.readn1eof()
-				continue
-			case 6: // typ = jsonNumFloat
-				eNeg = true
-				state = 7
-			default:
-				break LOOP
-			}
-		case '.':
-			switch state {
-			case 0, 2: // typ = jsonNumFloat
-				state = 4
-				n.dot = true
-			default:
-				break LOOP
-			}
-		case 'e', 'E':
-			switch state {
-			case 0, 2, 4: // typ = jsonNumFloat
-				state = 6
-				// n.mantissaEndIndex = int16(len(n.bytes))
-				n.explicitExponent = true
-			default:
-				break LOOP
-			}
-		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-			switch state {
-			case 0:
-				state = 2
-				fallthrough
-			case 2:
-				fallthrough
-			case 4:
-				if n.dot {
-					n.exponent--
-				}
-				if n.mantissa >= jsonNumUintCutoff {
-					n.manOverflow = true
-					break
-				}
-				v := uint64(b - '0')
-				n.mantissa *= 10
-				if v != 0 {
-					n1 := n.mantissa + v
-					if n1 < n.mantissa || n1 > jsonNumUintMaxVal {
-						n.manOverflow = true // n+v overflows
-						break
-					}
-					n.mantissa = n1
-				}
-			case 6:
-				state = 7
-				fallthrough
-			case 7:
-				if !(b == '0' && e == 0) {
-					e = e*10 + int16(b-'0')
-				}
-			default:
-				break LOOP
-			}
-		case '"':
-			if str {
-				if storeBytes {
-					d.bs = append(d.bs, '"')
-				}
-				b, eof = r.readn1eof()
-			}
-			break LOOP
-		default:
-			break LOOP
-		}
-		if storeBytes {
-			d.bs = append(d.bs, b)
-		}
-		b, eof = r.readn1eof()
-	}
-
-	if jsonTruncateMantissa && n.mantissa != 0 {
-		for n.mantissa%10 == 0 {
-			n.mantissa /= 10
-			n.exponent++
-		}
-	}
-
-	if e != 0 {
-		if eNeg {
-			n.exponent -= e
-		} else {
-			n.exponent += e
-		}
-	}
-
-	// d.n = n
-
-	if !eof {
-		if jsonUnreadAfterDecNum {
-			r.unreadn1()
-		} else {
-			if !jsonIsWS(b) {
-				d.tok = b
-			}
-		}
-	}
-	// fmt.Printf("1: n: bytes: %s, neg: %v, dot: %v, exponent: %v, mantissaEndIndex: %v\n",
-	// 	n.bytes, n.neg, n.dot, n.exponent, n.mantissaEndIndex)
 	return
 }
 
 func (d *jsonDecDriver) DecodeInt(bitsize uint8) (i int64) {
-	d.decNum(false)
-	n := &d.n
-	if n.manOverflow {
-		d.d.errorf("json: overflow integer after: %v", n.mantissa)
+	bs := d.decNumBytes()
+	i, err := strconv.ParseInt(stringView(bs), 10, int(bitsize))
+	if err != nil {
+		d.d.errorf("json: decode int from %s: %v", bs, err)
 		return
 	}
-	var u uint64
-	if n.exponent == 0 {
-		u = n.mantissa
-	} else if n.exponent < 0 {
-		d.d.errorf("json: fractional integer")
-		return
-	} else if n.exponent > 0 {
-		var overflow bool
-		if u, overflow = n.uintExp(); overflow {
-			d.d.errorf("json: overflow integer")
-			return
-		}
-	}
-	i = int64(u)
-	if n.neg {
-		i = -i
-	}
-	if chkOvf.Int(i, bitsize) {
-		d.d.errorf("json: overflow %v bits: %s", bitsize, d.bs)
-		return
-	}
-	// fmt.Printf("DecodeInt: %v\n", i)
-	return
-}
-
-// floatVal MUST only be called after a decNum, as d.bs now contains the bytes of the number
-func (d *jsonDecDriver) floatVal() (f float64) {
-	f, useStrConv := d.n.floatVal()
-	if useStrConv {
-		var err error
-		if f, err = strconv.ParseFloat(stringView(d.bs), 64); err != nil {
-			panic(fmt.Errorf("parse float: %s, %v", d.bs, err))
-		}
-		if d.n.neg {
-			f = -f
-		}
-	}
-	return
-}
-
-func (d *jsonDecDriver) DecodeUint(bitsize uint8) (u uint64) {
-	d.decNum(false)
-	n := &d.n
-	if n.neg {
-		d.d.errorf("json: unsigned integer cannot be negative")
-		return
-	}
-	if n.manOverflow {
-		d.d.errorf("json: overflow integer after: %v", n.mantissa)
-		return
-	}
-	if n.exponent == 0 {
-		u = n.mantissa
-	} else if n.exponent < 0 {
-		d.d.errorf("json: fractional integer")
-		return
-	} else if n.exponent > 0 {
-		var overflow bool
-		if u, overflow = n.uintExp(); overflow {
-			d.d.errorf("json: overflow integer")
-			return
-		}
-	}
-	if chkOvf.Uint(u, bitsize) {
-		d.d.errorf("json: overflow %v bits: %s", bitsize, d.bs)
-		return
-	}
-	// fmt.Printf("DecodeUint: %v\n", u)
 	return
 }
 
 func (d *jsonDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
-	d.decNum(true)
-	f = d.floatVal()
-	if chkOverflow32 && chkOvf.Float32(f) {
-		d.d.errorf("json: overflow float32: %v, %s", f, d.bs)
+	bs := d.decNumBytes()
+	bitsize := 64
+	if chkOverflow32 {
+		bitsize = 32
+	}
+	f, err := strconv.ParseFloat(stringView(bs), bitsize)
+	if err != nil {
+		d.d.errorf("json: decode float from %s: %v", bs, err)
 		return
 	}
 	return
@@ -918,23 +775,23 @@ func (d *jsonDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxta
 	return
 }
 
-func (d *jsonDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) {
+func (d *jsonDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 	// if decoding into raw bytes, and the RawBytesExt is configured, use it to decode.
-	if !isstring && d.se.i != nil {
+	if d.se.i != nil {
 		bsOut = bs
 		d.DecodeExt(&bsOut, 0, &d.se)
 		return
 	}
 	d.appendStringAsBytes()
-	// if isstring, then just return the bytes, even if it is using the scratch buffer.
-	// the bytes will be converted to a string as needed.
-	if isstring {
-		return d.bs
-	}
-	// if appendStringAsBytes returned a zero-len slice, then treat as nil.
-	// This should only happen for null, and "".
+	// base64 encodes []byte{} as "", and we encode nil []byte as null.
+	// Consequently, base64 should decode null as a nil []byte, and "" as an empty []byte{}.
+	// appendStringAsBytes returns a zero-len slice for both, so as not to reset d.bs.
+	// However, it sets a fnull field to true, so we can check if a null was found.
 	if len(d.bs) == 0 {
-		return nil
+		if d.fnull {
+			return nil
+		}
+		return []byte{}
 	}
 	bs0 := d.bs
 	slen := base64.StdEncoding.DecodedLen(len(bs0))
@@ -956,174 +813,213 @@ func (d *jsonDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut [
 	return
 }
 
+const jsonAlwaysReturnInternString = false
+
 func (d *jsonDecDriver) DecodeString() (s string) {
 	d.appendStringAsBytes()
 	// if x := d.s.sc; x != nil && x.so && x.st == '}' { // map key
-	if d.c == containerMapKey {
+	if jsonAlwaysReturnInternString || d.c == containerMapKey {
 		return d.d.string(d.bs)
 	}
 	return string(d.bs)
 }
 
+func (d *jsonDecDriver) DecodeStringAsBytes() (s []byte) {
+	d.appendStringAsBytes()
+	return d.bs
+}
+
 func (d *jsonDecDriver) appendStringAsBytes() {
 	if d.tok == 0 {
-		var b byte
-		r := d.r
-		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-		}
-		d.tok = b
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
 	}
 
-	// handle null as a string
-	if d.tok == 'n' {
-		d.readStrIdx(10, 13) // ull
-		d.bs = d.bs[:0]
+	d.fnull = false
+	if d.tok != '"' {
+		// d.d.errorf("json: expect char '%c' but got char '%c'", '"', d.tok)
+		// handle non-string scalar: null, true, false or a number
+		switch d.tok {
+		case 'n':
+			d.readSymbol3('u', 'l', 'l') // d.readLiteralIdx(10, 13) // ull
+			d.bs = d.bs[:0]
+			d.fnull = true
+		case 'f':
+			d.readSymbol4('a', 'l', 's', 'e') // d.readLiteralIdx(5, 9) // alse
+			d.bs = d.bs[:5]
+			copy(d.bs, "false")
+		case 't':
+			d.readSymbol3('r', 'u', 'e') // d.readLiteralIdx(1, 4) // rue
+			d.bs = d.bs[:4]
+			copy(d.bs, "true")
+		default:
+			// try to parse a valid number
+			bs := d.decNumBytes()
+			d.bs = d.bs[:len(bs)]
+			copy(d.bs, bs)
+		}
 		return
 	}
 
-	if d.tok != '"' {
-		d.d.errorf("json: expect char '%c' but got char '%c'", '"', d.tok)
-	}
 	d.tok = 0
-
-	v := d.bs[:0]
-	var c uint8
 	r := d.r
-	for {
-		c = r.readn1()
-		if c == '"' {
-			break
-		} else if c == '\\' {
-			c = r.readn1()
-			switch c {
-			case '"', '\\', '/', '\'':
-				v = append(v, c)
-			case 'b':
-				v = append(v, '\b')
-			case 'f':
-				v = append(v, '\f')
-			case 'n':
-				v = append(v, '\n')
-			case 'r':
-				v = append(v, '\r')
-			case 't':
-				v = append(v, '\t')
-			case 'u':
-				rr := d.jsonU4(false)
-				// fmt.Printf("$$$$$$$$$: is surrogate: %v\n", utf16.IsSurrogate(rr))
-				if utf16.IsSurrogate(rr) {
-					rr = utf16.DecodeRune(rr, d.jsonU4(true))
-				}
-				w2 := utf8.EncodeRune(d.bstr[:], rr)
-				v = append(v, d.bstr[:w2]...)
-			default:
-				d.d.errorf("json: unsupported escaped value: %c", c)
-			}
-		} else {
-			v = append(v, c)
+	var cs = r.readUntil(d.b2[:0], '"')
+	var cslen = len(cs)
+	var c uint8
+	v := d.bs[:0]
+	// append on each byte seen can be expensive, so we just
+	// keep track of where we last read a contiguous set of
+	// non-special bytes (using cursor variable),
+	// and when we see a special byte
+	// e.g. end-of-slice, " or \,
+	// we will append the full range into the v slice before proceeding
+	for i, cursor := 0, 0; ; {
+		if i == cslen {
+			v = append(v, cs[cursor:]...)
+			cs = r.readUntil(d.b2[:0], '"')
+			cslen = len(cs)
+			i, cursor = 0, 0
 		}
+		c = cs[i]
+		if c == '"' {
+			v = append(v, cs[cursor:i]...)
+			break
+		}
+		if c != '\\' {
+			i++
+			continue
+		}
+		v = append(v, cs[cursor:i]...)
+		i++
+		c = cs[i]
+		switch c {
+		case '"', '\\', '/', '\'':
+			v = append(v, c)
+		case 'b':
+			v = append(v, '\b')
+		case 'f':
+			v = append(v, '\f')
+		case 'n':
+			v = append(v, '\n')
+		case 'r':
+			v = append(v, '\r')
+		case 't':
+			v = append(v, '\t')
+		case 'u':
+			var r rune
+			var rr uint32
+			c = cs[i+4] // may help reduce bounds-checking
+			for j := 1; j < 5; j++ {
+				c = jsonU4Set[cs[i+j]]
+				if c == jsonU4SetErrVal {
+					d.d.errorf(`json: unquoteStr: invalid hex char in \u unicode sequence: %q`, c)
+				}
+				rr = rr*16 + uint32(c)
+			}
+			r = rune(rr)
+			i += 4
+			if utf16.IsSurrogate(r) {
+				if !(cs[i+2] == 'u' && cs[i+i] == '\\') {
+					d.d.errorf(`json: unquoteStr: invalid unicode sequence. Expecting \u`)
+					return
+				}
+				i += 2
+				c = cs[i+4] // may help reduce bounds-checking
+				var rr1 uint32
+				for j := 1; j < 5; j++ {
+					c = jsonU4Set[cs[i+j]]
+					if c == jsonU4SetErrVal {
+						d.d.errorf(`json: unquoteStr: invalid hex char in \u unicode sequence: %q`, c)
+					}
+					rr1 = rr1*16 + uint32(c)
+				}
+				r = utf16.DecodeRune(r, rune(rr1))
+				i += 4
+			}
+			w2 := utf8.EncodeRune(d.bstr[:], r)
+			v = append(v, d.bstr[:w2]...)
+		default:
+			d.d.errorf("json: unsupported escaped value: %c", c)
+		}
+		i++
+		cursor = i
 	}
 	d.bs = v
 }
 
-func (d *jsonDecDriver) jsonU4(checkSlashU bool) rune {
-	r := d.r
-	if checkSlashU && !(r.readn1() == '\\' && r.readn1() == 'u') {
-		d.d.errorf(`json: unquoteStr: invalid unicode sequence. Expecting \u`)
-		return 0
-	}
-	// u, _ := strconv.ParseUint(string(d.bstr[:4]), 16, 64)
-	var u uint32
-	for i := 0; i < 4; i++ {
-		v := r.readn1()
-		if '0' <= v && v <= '9' {
-			v = v - '0'
-		} else if 'a' <= v && v <= 'z' {
-			v = v - 'a' + 10
-		} else if 'A' <= v && v <= 'Z' {
-			v = v - 'A' + 10
-		} else {
-			d.d.errorf(`json: unquoteStr: invalid hex char in \u unicode sequence: %q`, v)
-			return 0
-		}
-		u = u*16 + uint32(v)
-	}
-	return rune(u)
-}
+// func (d *jsonDecDriver) jsonU4Arr(bs [4]byte) (r rune) {
+// 	// u, _ := strconv.ParseUint(string(d.bstr[:4]), 16, 64)
+// 	var u uint32
+// 	for _, v := range bs {
+// 		if '0' <= v && v <= '9' {
+// 			v = v - '0'
+// 		} else if 'a' <= v && v <= 'f' {
+// 			v = v - 'a' + 10
+// 		} else if 'A' <= v && v <= 'f' {
+// 			v = v - 'A' + 10
+// 		} else {
+// 			// d.d.errorf(`json: unquoteStr: invalid hex char in \u unicode sequence: %q`, v)
+// 			return utf8.RuneError
+// 		}
+// 		u = u*16 + uint32(v)
+// 	}
+// 	return rune(u)
+// }
 
 func (d *jsonDecDriver) DecodeNaked() {
-	z := &d.d.n
+	z := d.d.n
 	// var decodeFurther bool
 
 	if d.tok == 0 {
-		var b byte
-		r := d.r
-		for b = r.readn1(); jsonIsWS(b); b = r.readn1() {
-		}
-		d.tok = b
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
 	}
 	switch d.tok {
 	case 'n':
-		d.readStrIdx(10, 13) // ull
+		d.readSymbol3('u', 'l', 'l') // d.readLiteralIdx(10, 13) // ull
 		z.v = valueTypeNil
 	case 'f':
-		d.readStrIdx(5, 9) // alse
+		d.readSymbol4('a', 'l', 's', 'e') // d.readLiteralIdx(5, 9) // alse
 		z.v = valueTypeBool
 		z.b = false
 	case 't':
-		d.readStrIdx(1, 4) // rue
+		d.readSymbol3('r', 'u', 'e') // d.readLiteralIdx(1, 4) // rue
 		z.v = valueTypeBool
 		z.b = true
 	case '{':
-		z.v = valueTypeMap
-		// d.tok = 0 // don't consume. kInterfaceNaked will call ReadMapStart
-		// decodeFurther = true
+		z.v = valueTypeMap // don't consume. kInterfaceNaked will call ReadMapStart
 	case '[':
-		z.v = valueTypeArray
-		// d.tok = 0 // don't consume. kInterfaceNaked will call ReadArrayStart
-		// decodeFurther = true
+		z.v = valueTypeArray // don't consume. kInterfaceNaked will call ReadArrayStart
 	case '"':
 		z.v = valueTypeString
 		z.s = d.DecodeString()
 	default: // number
-		d.decNum(true)
-		n := &d.n
-		// if the string had a any of [.eE], then decode as float.
-		switch {
-		case n.explicitExponent, n.dot, n.exponent < 0, n.manOverflow:
+		bs := d.decNumBytes()
+		var err error
+		if len(bs) == 0 {
+			d.d.errorf("json: decode number from empty string")
+			return
+		} else if d.h.PreferFloat || jsonIsFloatBytesB3(bs) { // bytes.IndexByte(bs, '.') != -1 ||...
+			// } else if d.h.PreferFloat || bytes.ContainsAny(bs, ".eE") {
 			z.v = valueTypeFloat
-			z.f = d.floatVal()
-		case n.exponent == 0:
-			u := n.mantissa
-			switch {
-			case n.neg:
-				z.v = valueTypeInt
-				z.i = -int64(u)
-			case d.h.SignedInteger:
-				z.v = valueTypeInt
-				z.i = int64(u)
-			default:
-				z.v = valueTypeUint
-				z.u = u
+			z.f, err = strconv.ParseFloat(stringView(bs), 64)
+		} else if d.h.SignedInteger || bs[0] == '-' {
+			z.v = valueTypeInt
+			z.i, err = strconv.ParseInt(stringView(bs), 10, 64)
+		} else {
+			z.v = valueTypeUint
+			z.u, err = strconv.ParseUint(stringView(bs), 10, 64)
+		}
+		if err != nil {
+			if z.v == valueTypeInt || z.v == valueTypeUint {
+				if v, ok := err.(*strconv.NumError); ok && (v.Err == strconv.ErrRange || v.Err == strconv.ErrSyntax) {
+					z.v = valueTypeFloat
+					z.f, err = strconv.ParseFloat(stringView(bs), 64)
+				}
 			}
-		default:
-			u, overflow := n.uintExp()
-			switch {
-			case overflow:
-				z.v = valueTypeFloat
-				z.f = d.floatVal()
-			case n.neg:
-				z.v = valueTypeInt
-				z.i = -int64(u)
-			case d.h.SignedInteger:
-				z.v = valueTypeInt
-				z.i = int64(u)
-			default:
-				z.v = valueTypeUint
-				z.u = u
+			if err != nil {
+				d.d.errorf("json: decode number from %s: %v", bs, err)
+				return
 			}
 		}
-		// fmt.Printf("DecodeNaked: Number: %T, %v\n", v, v)
 	}
 	// if decodeFurther {
 	// 	d.s.sc.retryRead()
@@ -1152,6 +1048,7 @@ func (d *jsonDecDriver) DecodeNaked() {
 type JsonHandle struct {
 	textEncodingType
 	BasicHandle
+
 	// RawBytesExt, if configured, is used to encode and decode raw bytes in a custom way.
 	// If not configured, raw bytes are encoded to/from base64 text.
 	RawBytesExt InterfaceExt
@@ -1173,8 +1070,28 @@ type JsonHandle struct {
 	//             containing the exact integer representation as a decimal.
 	//   - else    encode all integers as a json number (default)
 	IntegerAsString uint8
+
+	// HTMLCharsAsIs controls how to encode some special characters to html: < > &
+	//
+	// By default, we encode them as \uXXX
+	// to prevent security holes when served from some browsers.
+	HTMLCharsAsIs bool
+
+	// PreferFloat says that we will default to decoding a number as a float.
+	// If not set, we will examine the characters of the number and decode as an
+	// integer type if it doesn't have any of the characters [.eE].
+	PreferFloat bool
+
+	// TermWhitespace says that we add a whitespace character
+	// at the end of an encoding.
+	//
+	// The whitespace is important, especially if using numbers in a context
+	// where multiple items are written to a stream.
+	TermWhitespace bool
 }
 
+func (h *JsonHandle) hasElemSeparators() bool { return true }
+
 func (h *JsonHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
 	return h.SetExt(rt, tag, &setExtWrapper{i: ext})
 }
@@ -1221,14 +1138,35 @@ func (d *jsonDecDriver) reset() {
 		d.bs = d.bs[:0]
 	}
 	d.c, d.tok = 0, 0
-	d.n.reset()
+	// d.n.reset()
 }
 
-var jsonEncodeTerminate = []byte{' '}
+// func jsonIsFloatBytes(bs []byte) bool {
+// 	for _, v := range bs {
+// 		// if v == '.' || v == 'e' || v == 'E' {
+// 		if jsonIsFloatSet.isset(v) {
+// 			return true
+// 		}
+// 	}
+// 	return false
+// }
 
-func (h *JsonHandle) rpcEncodeTerminate() []byte {
-	return jsonEncodeTerminate
+func jsonIsFloatBytesB2(bs []byte) bool {
+	return bytes.IndexByte(bs, '.') != -1 ||
+		bytes.IndexByte(bs, 'E') != -1
 }
 
+func jsonIsFloatBytesB3(bs []byte) bool {
+	return bytes.IndexByte(bs, '.') != -1 ||
+		bytes.IndexByte(bs, 'E') != -1 ||
+		bytes.IndexByte(bs, 'e') != -1
+}
+
+// var jsonEncodeTerminate = []byte{' '}
+
+// func (h *JsonHandle) rpcEncodeTerminate() []byte {
+// 	return jsonEncodeTerminate
+// }
+
 var _ decDriver = (*jsonDecDriver)(nil)
 var _ encDriver = (*jsonEncDriver)(nil)
diff --git a/vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl b/vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl
new file mode 100644
index 00000000000..6d716972a08
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl
@@ -0,0 +1,33 @@
+// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// ************************************************************
+// DO NOT EDIT. 
+// THIS FILE IS AUTO-GENERATED from mammoth-test.go.tmpl
+// ************************************************************
+
+package codec
+
+// TestMammoth has all the different paths optimized in fast-path
+// It has all the primitives, slices and maps.
+// 
+// For each of those types, it has a pointer and a non-pointer field.
+
+type TestMammoth struct {
+
+{{range .Values }}{{if .Primitive }}{{/*
+*/}}{{ .MethodNamePfx "F" true }} {{ .Primitive }}
+{{ .MethodNamePfx "Fptr" true }} *{{ .Primitive }}
+{{end}}{{end}}
+
+{{range .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
+*/}}{{ .MethodNamePfx "F" false }} []{{ .Elem }}
+{{ .MethodNamePfx "Fptr" false }} *[]{{ .Elem }}
+{{end}}{{end}}{{end}}
+
+{{range .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
+*/}}{{ .MethodNamePfx "F" false }} map[{{ .MapKey }}]{{ .Elem }}
+{{ .MethodNamePfx "Fptr" false }} *map[{{ .MapKey }}]{{ .Elem }}
+{{end}}{{end}}{{end}}
+
+}
diff --git a/vendor/github.com/ugorji/go/codec/msgpack.go b/vendor/github.com/ugorji/go/codec/msgpack.go
index e79830b562a..fcc3177aaab 100644
--- a/vendor/github.com/ugorji/go/codec/msgpack.go
+++ b/vendor/github.com/ugorji/go/codec/msgpack.go
@@ -104,7 +104,8 @@ var (
 
 type msgpackEncDriver struct {
 	noBuiltInTypes
-	encNoSeparator
+	encDriverNoopContainerWriter
+	// encNoSeparator
 	e *Encoder
 	w encWriter
 	h *MsgpackHandle
@@ -213,21 +214,22 @@ func (e *msgpackEncDriver) encodeExtPreamble(xtag byte, l int) {
 	}
 }
 
-func (e *msgpackEncDriver) EncodeArrayStart(length int) {
+func (e *msgpackEncDriver) WriteArrayStart(length int) {
 	e.writeContainerLen(msgpackContainerList, length)
 }
 
-func (e *msgpackEncDriver) EncodeMapStart(length int) {
+func (e *msgpackEncDriver) WriteMapStart(length int) {
 	e.writeContainerLen(msgpackContainerMap, length)
 }
 
 func (e *msgpackEncDriver) EncodeString(c charEncoding, s string) {
+	slen := len(s)
 	if c == c_RAW && e.h.WriteExt {
-		e.writeContainerLen(msgpackContainerBin, len(s))
+		e.writeContainerLen(msgpackContainerBin, slen)
 	} else {
-		e.writeContainerLen(msgpackContainerStr, len(s))
+		e.writeContainerLen(msgpackContainerStr, slen)
 	}
-	if len(s) > 0 {
+	if slen > 0 {
 		e.w.writestr(s)
 	}
 }
@@ -237,12 +239,13 @@ func (e *msgpackEncDriver) EncodeSymbol(v string) {
 }
 
 func (e *msgpackEncDriver) EncodeStringBytes(c charEncoding, bs []byte) {
+	slen := len(bs)
 	if c == c_RAW && e.h.WriteExt {
-		e.writeContainerLen(msgpackContainerBin, len(bs))
+		e.writeContainerLen(msgpackContainerBin, slen)
 	} else {
-		e.writeContainerLen(msgpackContainerStr, len(bs))
+		e.writeContainerLen(msgpackContainerStr, slen)
 	}
-	if len(bs) > 0 {
+	if slen > 0 {
 		e.w.writeb(bs)
 	}
 }
@@ -272,8 +275,9 @@ type msgpackDecDriver struct {
 	bdRead bool
 	br     bool // bytes reader
 	noBuiltInTypes
-	noStreamingCodec
-	decNoSeparator
+	// noStreamingCodec
+	// decNoSeparator
+	decDriverNoopContainerReader
 }
 
 // Note: This returns either a primitive (int, bool, etc) for non-containers,
@@ -286,7 +290,7 @@ func (d *msgpackDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 	bd := d.bd
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch bd {
@@ -349,11 +353,11 @@ func (d *msgpackDecDriver) DecodeNaked() {
 				n.s = d.DecodeString()
 			} else {
 				n.v = valueTypeBytes
-				n.l = d.DecodeBytes(nil, false, false)
+				n.l = d.DecodeBytes(nil, false)
 			}
 		case bd == mpBin8, bd == mpBin16, bd == mpBin32:
 			n.v = valueTypeBytes
-			n.l = d.DecodeBytes(nil, false, false)
+			n.l = d.DecodeBytes(nil, false)
 		case bd == mpArray16, bd == mpArray32, bd >= mpFixArrayMin && bd <= mpFixArrayMax:
 			n.v = valueTypeArray
 			decodeFurther = true
@@ -525,17 +529,46 @@ func (d *msgpackDecDriver) DecodeBool() (b bool) {
 	return
 }
 
-func (d *msgpackDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) {
+func (d *msgpackDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
+
+	// DecodeBytes could be from: bin str fixstr fixarray array ...
 	var clen int
-	// ignore isstring. Expect that the bytes may be found from msgpackContainerStr or msgpackContainerBin
-	if bd := d.bd; bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
-		clen = d.readContainerLen(msgpackContainerBin)
-	} else {
+	vt := d.ContainerType()
+	switch vt {
+	case valueTypeBytes:
+		// valueTypeBytes may be a mpBin or an mpStr container
+		if bd := d.bd; bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
+			clen = d.readContainerLen(msgpackContainerBin)
+		} else {
+			clen = d.readContainerLen(msgpackContainerStr)
+		}
+	case valueTypeString:
 		clen = d.readContainerLen(msgpackContainerStr)
+	case valueTypeArray:
+		clen = d.readContainerLen(msgpackContainerList)
+		// ensure everything after is one byte each
+		for i := 0; i < clen; i++ {
+			d.readNextBd()
+			if d.bd == mpNil {
+				bs = append(bs, 0)
+			} else if d.bd == mpUint8 {
+				bs = append(bs, d.r.readn1())
+			} else {
+				d.d.errorf("cannot read non-byte into a byte array")
+				return
+			}
+		}
+		d.bdRead = false
+		return bs
+	default:
+		d.d.errorf("invalid container type: expecting bin|str|array")
+		return
 	}
+
+	// these are (bin|str)(8|16|32)
 	// println("DecodeBytes: clen: ", clen)
 	d.bdRead = false
 	// bytes may be nil, so handle it. if nil, clen=-1.
@@ -549,11 +582,15 @@ func (d *msgpackDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOu
 			bs = d.b[:]
 		}
 	}
-	return decByteSlice(d.r, clen, bs)
+	return decByteSlice(d.r, clen, d.d.h.MaxInitLen, bs)
 }
 
 func (d *msgpackDecDriver) DecodeString() (s string) {
-	return string(d.DecodeBytes(d.b[:], true, true))
+	return string(d.DecodeBytes(d.b[:], true))
+}
+
+func (d *msgpackDecDriver) DecodeStringAsBytes() (s []byte) {
+	return d.DecodeBytes(d.b[:], true)
 }
 
 func (d *msgpackDecDriver) readNextBd() {
@@ -569,6 +606,9 @@ func (d *msgpackDecDriver) uncacheRead() {
 }
 
 func (d *msgpackDecDriver) ContainerType() (vt valueType) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	bd := d.bd
 	if bd == mpNil {
 		return valueTypeNil
@@ -621,10 +661,16 @@ func (d *msgpackDecDriver) readContainerLen(ct msgpackContainerType) (clen int)
 }
 
 func (d *msgpackDecDriver) ReadMapStart() int {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	return d.readContainerLen(msgpackContainerMap)
 }
 
 func (d *msgpackDecDriver) ReadArrayStart() int {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	return d.readContainerLen(msgpackContainerList)
 }
 
@@ -678,10 +724,10 @@ func (d *msgpackDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs
 	}
 	xbd := d.bd
 	if xbd == mpBin8 || xbd == mpBin16 || xbd == mpBin32 {
-		xbs = d.DecodeBytes(nil, false, true)
+		xbs = d.DecodeBytes(nil, true)
 	} else if xbd == mpStr8 || xbd == mpStr16 || xbd == mpStr32 ||
 		(xbd >= mpFixStrMin && xbd <= mpFixStrMax) {
-		xbs = d.DecodeBytes(nil, true, true)
+		xbs = d.DecodeStringAsBytes()
 	} else {
 		clen := d.readExtLen()
 		xtag = d.r.readn1()
@@ -716,6 +762,7 @@ type MsgpackHandle struct {
 	// a []byte or string based on the setting of RawToString.
 	WriteExt bool
 	binaryEncodingType
+	noElemSeparators
 }
 
 func (h *MsgpackHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
@@ -727,7 +774,7 @@ func (h *MsgpackHandle) newEncDriver(e *Encoder) encDriver {
 }
 
 func (h *MsgpackHandle) newDecDriver(d *Decoder) decDriver {
-	return &msgpackDecDriver{d: d, r: d.r, h: h, br: d.bytes}
+	return &msgpackDecDriver{d: d, h: h, r: d.r, br: d.bytes}
 }
 
 func (e *msgpackEncDriver) reset() {
@@ -735,7 +782,7 @@ func (e *msgpackEncDriver) reset() {
 }
 
 func (d *msgpackDecDriver) reset() {
-	d.r = d.d.r
+	d.r, d.br = d.d.r, d.d.bytes
 	d.bd, d.bdRead = 0, false
 }
 
diff --git a/vendor/github.com/ugorji/go/codec/noop.go b/vendor/github.com/ugorji/go/codec/noop.go
index cfee3d084dc..015af581a53 100644
--- a/vendor/github.com/ugorji/go/codec/noop.go
+++ b/vendor/github.com/ugorji/go/codec/noop.go
@@ -1,6 +1,8 @@
 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
+// +build ignore
+
 package codec
 
 import (
@@ -105,10 +107,9 @@ func (h *noopDrv) DecodeUint(bitsize uint8) (ui uint64)       { return uint64(h.
 func (h *noopDrv) DecodeFloat(chkOverflow32 bool) (f float64) { return float64(h.m(95)) }
 func (h *noopDrv) DecodeBool() (b bool)                       { return h.m(2) == 0 }
 func (h *noopDrv) DecodeString() (s string)                   { return h.S[h.m(8)] }
+func (h *noopDrv) DecodeStringAsBytes() []byte                { return h.DecodeBytes(nil, true) }
 
-// func (h *noopDrv) DecodeStringAsBytes(bs []byte) []byte       { return h.DecodeBytes(bs) }
-
-func (h *noopDrv) DecodeBytes(bs []byte, isstring, zerocopy bool) []byte { return h.B[h.m(len(h.B))] }
+func (h *noopDrv) DecodeBytes(bs []byte, zerocopy bool) []byte { return h.B[h.m(len(h.B))] }
 
 func (h *noopDrv) ReadEnd() { h.end() }
 
diff --git a/vendor/github.com/ugorji/go/codec/prebuild.go b/vendor/github.com/ugorji/go/codec/prebuild.go
deleted file mode 100644
index 2353263e88a..00000000000
--- a/vendor/github.com/ugorji/go/codec/prebuild.go
+++ /dev/null
@@ -1,3 +0,0 @@
-package codec
-
-//go:generate bash prebuild.sh
diff --git a/vendor/github.com/ugorji/go/codec/prebuild.sh b/vendor/github.com/ugorji/go/codec/prebuild.sh
deleted file mode 100755
index 909f4bb0f24..00000000000
--- a/vendor/github.com/ugorji/go/codec/prebuild.sh
+++ /dev/null
@@ -1,199 +0,0 @@
-#!/bin/bash
-
-# _needgen is a helper function to tell if we need to generate files for msgp, codecgen.
-_needgen() {
-    local a="$1"
-    zneedgen=0
-    if [[ ! -e "$a" ]]
-    then
-        zneedgen=1
-        echo 1
-        return 0
-    fi 
-    for i in `ls -1 *.go.tmpl gen.go values_test.go`
-    do
-        if [[ "$a" -ot "$i" ]]
-        then
-            zneedgen=1
-            echo 1
-            return 0
-        fi 
-    done 
-    echo 0
-}
-
-# _build generates fast-path.go and gen-helper.go.
-# 
-# It is needed because there is some dependency between the generated code
-# and the other classes. Consequently, we have to totally remove the 
-# generated files and put stubs in place, before calling "go run" again
-# to recreate them.
-_build() {
-    if ! [[ "${zforce}" == "1" ||
-                "1" == $( _needgen "fast-path.generated.go" ) ||
-                "1" == $( _needgen "gen-helper.generated.go" ) ||
-                "1" == $( _needgen "gen.generated.go" ) ||
-                1 == 0 ]]
-    then
-        return 0
-    fi 
-
-   # echo "Running prebuild"
-    if [ "${zbak}" == "1" ] 
-    then
-        # echo "Backing up old generated files"
-        _zts=`date '+%m%d%Y_%H%M%S'`
-        _gg=".generated.go"
-        [ -e "gen-helper${_gg}" ] && mv gen-helper${_gg} gen-helper${_gg}__${_zts}.bak
-        [ -e "fast-path${_gg}" ] && mv fast-path${_gg} fast-path${_gg}__${_zts}.bak
-        # [ -e "safe${_gg}" ] && mv safe${_gg} safe${_gg}__${_zts}.bak
-        # [ -e "unsafe${_gg}" ] && mv unsafe${_gg} unsafe${_gg}__${_zts}.bak
-    else 
-        rm -f fast-path.generated.go gen.generated.go gen-helper.generated.go \
-           *safe.generated.go *_generated_test.go *.generated_ffjson_expose.go
-    fi
-
-    cat > gen.generated.go <<EOF
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
-// Use of this source code is governed by a MIT license found in the LICENSE file.
-
-package codec
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED FROM gen-dec-(map|array).go.tmpl
-
-const genDecMapTmpl = \`
-EOF
-
-    cat >> gen.generated.go < gen-dec-map.go.tmpl
-
-    cat >> gen.generated.go <<EOF
-\`
-
-const genDecListTmpl = \`
-EOF
-
-    cat >> gen.generated.go < gen-dec-array.go.tmpl
-
-    cat >> gen.generated.go <<EOF
-\`
-
-EOF
-
-    cat > gen-from-tmpl.codec.generated.go <<EOF
-package codec 
-import "io"
-func GenInternalGoFile(r io.Reader, w io.Writer, safe bool) error {
-return genInternalGoFile(r, w, safe)
-}
-EOF
-    
-    cat > gen-from-tmpl.generated.go <<EOF
-//+build ignore
-
-package main
-
-//import "flag"
-import "ugorji.net/codec"
-import "os"
-
-func run(fnameIn, fnameOut string, safe bool) {
-fin, err := os.Open(fnameIn)
-if err != nil { panic(err) }
-defer fin.Close()
-fout, err := os.Create(fnameOut)
-if err != nil { panic(err) }
-defer fout.Close()
-err = codec.GenInternalGoFile(fin, fout, safe)
-if err != nil { panic(err) }
-}
-
-func main() {
-// do not make safe/unsafe variants. 
-// Instead, depend on escape analysis, and place string creation and usage appropriately.
-// run("unsafe.go.tmpl", "safe.generated.go", true)
-// run("unsafe.go.tmpl", "unsafe.generated.go", false)
-run("fast-path.go.tmpl", "fast-path.generated.go", false)
-run("gen-helper.go.tmpl", "gen-helper.generated.go", false)
-}
-
-EOF
-    go run -tags=notfastpath gen-from-tmpl.generated.go && \
-        rm -f gen-from-tmpl.*generated.go 
-}
-
-_codegenerators() {
-    if [[ $zforce == "1" || 
-                "1" == $( _needgen "values_codecgen${zsfx}" ) ||
-                "1" == $( _needgen "values_msgp${zsfx}" ) ||
-                "1" == $( _needgen "values_ffjson${zsfx}" ) ||
-                1 == 0 ]] 
-    then
-        # codecgen creates some temporary files in the directory (main, pkg).
-        # Consequently, we should start msgp and ffjson first, and also put a small time latency before
-        # starting codecgen.
-        # Without this, ffjson chokes on one of the temporary files from codecgen.
-        if [[ $zexternal == "1" ]]
-        then 
-            echo "ffjson ... " && \
-                ffjson -w values_ffjson${zsfx} $zfin &
-            zzzIdFF=$!
-            echo "msgp ... " && \
-                msgp -tests=false -o=values_msgp${zsfx} -file=$zfin &
-            zzzIdMsgp=$!
-            
-            sleep 1 # give ffjson and msgp some buffer time. see note above.
-        fi
-        
-        echo "codecgen - !unsafe ... " && \
-            codecgen -rt codecgen -t 'x,codecgen,!unsafe' -o values_codecgen${zsfx} -d 19780 $zfin &
-        zzzIdC=$!
-        echo "codecgen - unsafe ... " && \
-            codecgen  -u -rt codecgen -t 'x,codecgen,unsafe' -o values_codecgen_unsafe${zsfx} -d 19781 $zfin &
-        zzzIdCU=$!
-        wait $zzzIdC $zzzIdCU $zzzIdMsgp $zzzIdFF && \
-            # remove (M|Unm)arshalJSON implementations, so they don't conflict with encoding/json bench \
-            if [[ $zexternal == "1" ]]
-            then
-                sed -i 's+ MarshalJSON(+ _MarshalJSON(+g' values_ffjson${zsfx} && \
-                    sed -i 's+ UnmarshalJSON(+ _UnmarshalJSON(+g' values_ffjson${zsfx}
-            fi && \
-            echo "generators done!" && \
-            true
-    fi 
-}
-
-# _init reads the arguments and sets up the flags
-_init() {
-OPTIND=1
-while getopts "fbx" flag
-do
-    case "x$flag" in 
-        'xf') zforce=1;;
-        'xb') zbak=1;;
-        'xx') zexternal=1;;
-        *) echo "prebuild.sh accepts [-fbx] only"; return 1;;
-    esac
-done
-shift $((OPTIND-1))
-OPTIND=1
-}
-
-# main script.
-# First ensure that this is being run from the basedir (i.e. dirname of script is .)
-if [ "." = `dirname $0` ]
-then
-    zmydir=`pwd`
-    zfin="test_values.generated.go"
-    zsfx="_generated_test.go"
-    # rm -f *_generated_test.go 
-    rm -f codecgen-*.go && \
-        _init "$@" && \
-        _build && \
-        cp $zmydir/values_test.go $zmydir/$zfin && \
-        _codegenerators && \
-        echo prebuild done successfully
-    rm -f $zmydir/$zfin
-else
-    echo "Script must be run from the directory it resides in"
-fi 
-
diff --git a/vendor/github.com/ugorji/go/codec/rpc.go b/vendor/github.com/ugorji/go/codec/rpc.go
index 8062bed3130..4c307804c33 100644
--- a/vendor/github.com/ugorji/go/codec/rpc.go
+++ b/vendor/github.com/ugorji/go/codec/rpc.go
@@ -5,18 +5,19 @@ package codec
 
 import (
 	"bufio"
+	"errors"
 	"io"
 	"net/rpc"
 	"sync"
 )
 
-// rpcEncodeTerminator allows a handler specify a []byte terminator to send after each Encode.
-//
-// Some codecs like json need to put a space after each encoded value, to serve as a
-// delimiter for things like numbers (else json codec will continue reading till EOF).
-type rpcEncodeTerminator interface {
-	rpcEncodeTerminate() []byte
-}
+// // rpcEncodeTerminator allows a handler specify a []byte terminator to send after each Encode.
+// //
+// // Some codecs like json need to put a space after each encoded value, to serve as a
+// // delimiter for things like numbers (else json codec will continue reading till EOF).
+// type rpcEncodeTerminator interface {
+// 	rpcEncodeTerminate() []byte
+// }
 
 // Rpc provides a rpc Server or Client Codec for rpc communication.
 type Rpc interface {
@@ -52,6 +53,12 @@ type rpcCodec struct {
 func newRPCCodec(conn io.ReadWriteCloser, h Handle) rpcCodec {
 	bw := bufio.NewWriter(conn)
 	br := bufio.NewReader(conn)
+
+	// defensive: ensure that jsonH has TermWhitespace turned on.
+	if jsonH, ok := h.(*JsonHandle); ok && !jsonH.TermWhitespace {
+		panic(errors.New("rpc requires a JsonHandle with TermWhitespace set to true"))
+	}
+
 	return rpcCodec{
 		rwc: conn,
 		bw:  bw,
@@ -77,17 +84,17 @@ func (c *rpcCodec) write(obj1, obj2 interface{}, writeObj2, doFlush bool) (err e
 	if err = c.enc.Encode(obj1); err != nil {
 		return
 	}
-	t, tOk := c.h.(rpcEncodeTerminator)
-	if tOk {
-		c.bw.Write(t.rpcEncodeTerminate())
-	}
+	// t, tOk := c.h.(rpcEncodeTerminator)
+	// if tOk {
+	// 	c.bw.Write(t.rpcEncodeTerminate())
+	// }
 	if writeObj2 {
 		if err = c.enc.Encode(obj2); err != nil {
 			return
 		}
-		if tOk {
-			c.bw.Write(t.rpcEncodeTerminate())
-		}
+		// if tOk {
+		// 	c.bw.Write(t.rpcEncodeTerminate())
+		// }
 	}
 	if doFlush {
 		return c.bw.Flush()
diff --git a/vendor/github.com/ugorji/go/codec/simple.go b/vendor/github.com/ugorji/go/codec/simple.go
index d07208c874a..b69a15e75a3 100644
--- a/vendor/github.com/ugorji/go/codec/simple.go
+++ b/vendor/github.com/ugorji/go/codec/simple.go
@@ -30,7 +30,8 @@ const (
 
 type simpleEncDriver struct {
 	noBuiltInTypes
-	encNoSeparator
+	encDriverNoopContainerWriter
+	// encNoSeparator
 	e *Encoder
 	h *SimpleHandle
 	w encWriter
@@ -124,11 +125,11 @@ func (e *simpleEncDriver) encodeExtPreamble(xtag byte, length int) {
 	e.w.writen1(xtag)
 }
 
-func (e *simpleEncDriver) EncodeArrayStart(length int) {
+func (e *simpleEncDriver) WriteArrayStart(length int) {
 	e.encLen(simpleVdArray, length)
 }
 
-func (e *simpleEncDriver) EncodeMapStart(length int) {
+func (e *simpleEncDriver) WriteMapStart(length int) {
 	e.encLen(simpleVdMap, length)
 }
 
@@ -155,10 +156,10 @@ type simpleDecDriver struct {
 	bdRead bool
 	bd     byte
 	br     bool // bytes reader
+	b      [scratchByteArrayLen]byte
 	noBuiltInTypes
-	noStreamingCodec
-	decNoSeparator
-	b [scratchByteArrayLen]byte
+	// noStreamingCodec
+	decDriverNoopContainerReader
 }
 
 func (d *simpleDecDriver) readNextBd() {
@@ -174,6 +175,9 @@ func (d *simpleDecDriver) uncacheRead() {
 }
 
 func (d *simpleDecDriver) ContainerType() (vt valueType) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	if d.bd == simpleVdNil {
 		return valueTypeNil
 	} else if d.bd == simpleVdByteArray || d.bd == simpleVdByteArray+1 ||
@@ -315,11 +319,17 @@ func (d *simpleDecDriver) DecodeBool() (b bool) {
 }
 
 func (d *simpleDecDriver) ReadMapStart() (length int) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	d.bdRead = false
 	return d.decLen()
 }
 
 func (d *simpleDecDriver) ReadArrayStart() (length int) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	d.bdRead = false
 	return d.decLen()
 }
@@ -352,10 +362,14 @@ func (d *simpleDecDriver) decLen() int {
 }
 
 func (d *simpleDecDriver) DecodeString() (s string) {
-	return string(d.DecodeBytes(d.b[:], true, true))
+	return string(d.DecodeBytes(d.b[:], true))
 }
 
-func (d *simpleDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) {
+func (d *simpleDecDriver) DecodeStringAsBytes() (s []byte) {
+	return d.DecodeBytes(d.b[:], true)
+}
+
+func (d *simpleDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -372,7 +386,7 @@ func (d *simpleDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut
 			bs = d.b[:]
 		}
 	}
-	return decByteSlice(d.r, clen, bs)
+	return decByteSlice(d.r, clen, d.d.h.MaxInitLen, bs)
 }
 
 func (d *simpleDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) {
@@ -406,7 +420,7 @@ func (d *simpleDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs [
 		}
 		xbs = d.r.readx(l)
 	case simpleVdByteArray, simpleVdByteArray + 1, simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
-		xbs = d.DecodeBytes(nil, false, true)
+		xbs = d.DecodeBytes(nil, true)
 	default:
 		d.d.errorf("Invalid d.bd for extensions (Expecting extensions or byte array). Got: 0x%x", d.bd)
 		return
@@ -420,7 +434,7 @@ func (d *simpleDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch d.bd {
@@ -454,7 +468,7 @@ func (d *simpleDecDriver) DecodeNaked() {
 		n.s = d.DecodeString()
 	case simpleVdByteArray, simpleVdByteArray + 1, simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
 		n.v = valueTypeBytes
-		n.l = d.DecodeBytes(nil, false, false)
+		n.l = d.DecodeBytes(nil, false)
 	case simpleVdExt, simpleVdExt + 1, simpleVdExt + 2, simpleVdExt + 3, simpleVdExt + 4:
 		n.v = valueTypeExt
 		l := d.decLen()
@@ -499,6 +513,7 @@ func (d *simpleDecDriver) DecodeNaked() {
 type SimpleHandle struct {
 	BasicHandle
 	binaryEncodingType
+	noElemSeparators
 }
 
 func (h *SimpleHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
@@ -510,7 +525,7 @@ func (h *SimpleHandle) newEncDriver(e *Encoder) encDriver {
 }
 
 func (h *SimpleHandle) newDecDriver(d *Decoder) decDriver {
-	return &simpleDecDriver{d: d, r: d.r, h: h, br: d.bytes}
+	return &simpleDecDriver{d: d, h: h, r: d.r, br: d.bytes}
 }
 
 func (e *simpleEncDriver) reset() {
@@ -518,7 +533,7 @@ func (e *simpleEncDriver) reset() {
 }
 
 func (d *simpleDecDriver) reset() {
-	d.r = d.d.r
+	d.r, d.br = d.d.r, d.d.bytes
 	d.bd, d.bdRead = 0, false
 }
 
diff --git a/vendor/github.com/ugorji/go/codec/test.py b/vendor/github.com/ugorji/go/codec/test.py
index c0ad20b34cb..800376f6841 100755
--- a/vendor/github.com/ugorji/go/codec/test.py
+++ b/vendor/github.com/ugorji/go/codec/test.py
@@ -34,7 +34,7 @@ def get_test_data_list():
          True,
          u"null",
          None,
-         u"someday",
+         u"some&day>some<day",
          1328176922000002000,
          u"",
          -2206187877999998000,
@@ -84,7 +84,7 @@ def doRpcServer(port, stopTimeSec):
         def EchoStruct(self, msg):
             return ("%s" % msg)
     
-    addr = msgpackrpc.Address('localhost', port)
+    addr = msgpackrpc.Address('127.0.0.1', port)
     server = msgpackrpc.Server(EchoHandler())
     server.listen(addr)
     # run thread to stop it after stopTimeSec seconds if > 0
@@ -96,14 +96,14 @@ def doRpcServer(port, stopTimeSec):
     server.start()
 
 def doRpcClientToPythonSvc(port):
-    address = msgpackrpc.Address('localhost', port)
+    address = msgpackrpc.Address('127.0.0.1', port)
     client = msgpackrpc.Client(address, unpack_encoding='utf-8')
     print client.call("Echo123", "A1", "B2", "C3")
     print client.call("EchoStruct", {"A" :"Aa", "B":"Bb", "C":"Cc"})
    
 def doRpcClientToGoSvc(port):
     # print ">>>> port: ", port, " <<<<<"
-    address = msgpackrpc.Address('localhost', port)
+    address = msgpackrpc.Address('127.0.0.1', port)
     client = msgpackrpc.Client(address, unpack_encoding='utf-8')
     print client.call("TestRpcInt.Echo123", ["A1", "B2", "C3"])
     print client.call("TestRpcInt.EchoStruct", {"A" :"Aa", "B":"Bb", "C":"Cc"})
diff --git a/vendor/github.com/ugorji/go/codec/tests.sh b/vendor/github.com/ugorji/go/codec/tests.sh
deleted file mode 100755
index 342f336dfe1..00000000000
--- a/vendor/github.com/ugorji/go/codec/tests.sh
+++ /dev/null
@@ -1,102 +0,0 @@
-#!/bin/bash
-
-# Run all the different permutations of all the tests.
-# This helps ensure that nothing gets broken.
-
-_run() {
-    # 1. VARIATIONS: regular (t), canonical (c), IO R/W (i),
-    #                binc-nosymbols (n), struct2array (s), intern string (e),
-    #                json-indent (d), circular (l)
-    # 2. MODE: reflection (r), external (x), codecgen (g), unsafe (u), notfastpath (f)
-    # 3. OPTIONS: verbose (v), reset (z), must (m),
-    # 
-    # Use combinations of mode to get exactly what you want,
-    # and then pass the variations you need.
-
-    ztags=""
-    zargs=""
-    local OPTIND 
-    OPTIND=1
-    while getopts "_xurtcinsvgzmefdl" flag
-    do
-        case "x$flag" in 
-            'xr')  ;;
-            'xf') ztags="$ztags notfastpath" ;;
-            'xg') ztags="$ztags codecgen" ;;
-            'xx') ztags="$ztags x" ;;
-            'xu') ztags="$ztags unsafe" ;;
-            'xv') zargs="$zargs -tv" ;;
-            'xz') zargs="$zargs -tr" ;;
-            'xm') zargs="$zargs -tm" ;;
-            'xl') zargs="$zargs -tl" ;;
-            *) ;;
-        esac
-    done
-    # shift $((OPTIND-1))
-    printf '............. TAGS: %s .............\n' "$ztags"
-    # echo ">>>>>>> TAGS: $ztags"
-    
-    OPTIND=1
-    while getopts "_xurtcinsvgzmefdl" flag
-    do
-        case "x$flag" in 
-            'xt') printf ">>>>>>> REGULAR    : "; go test "-tags=$ztags" $zargs ; sleep 2 ;;
-            'xc') printf ">>>>>>> CANONICAL  : "; go test "-tags=$ztags" $zargs -tc; sleep 2 ;;
-            'xi') printf ">>>>>>> I/O        : "; go test "-tags=$ztags" $zargs -ti; sleep 2 ;;
-            'xn') printf ">>>>>>> NO_SYMBOLS : "; go test "-tags=$ztags" -run=Binc $zargs -tn; sleep 2 ;;
-            'xs') printf ">>>>>>> TO_ARRAY   : "; go test "-tags=$ztags" $zargs -ts; sleep 2 ;;
-            'xe') printf ">>>>>>> INTERN     : "; go test "-tags=$ztags" $zargs -te; sleep 2 ;;
-            'xd') printf ">>>>>>> INDENT     : ";
-                  go test "-tags=$ztags" -run=JsonCodecsTable -td=-1 $zargs;
-                  go test "-tags=$ztags" -run=JsonCodecsTable -td=8 $zargs;
-                  sleep 2 ;;
-            *) ;;
-        esac
-    done
-    shift $((OPTIND-1))
-
-    OPTIND=1
-}
-
-# echo ">>>>>>> RUNNING VARIATIONS OF TESTS"    
-if [[ "x$@" = "x"  || "x$@" = "x-A" ]]; then
-    # All: r, x, g, gu
-    _run "-_tcinsed_ml"  # regular
-    _run "-_tcinsed_ml_z" # regular with reset
-    _run "-_tcinsed_ml_f" # regular with no fastpath (notfastpath)
-    _run "-x_tcinsed_ml" # external
-    _run "-gx_tcinsed_ml" # codecgen: requires external
-    _run "-gxu_tcinsed_ml" # codecgen + unsafe
-elif [[ "x$@" = "x-Z" ]]; then
-    # Regular
-    _run "-_tcinsed_ml"  # regular
-    _run "-_tcinsed_ml_z" # regular with reset
-elif [[ "x$@" = "x-F" ]]; then
-    # regular with notfastpath
-    _run "-_tcinsed_ml_f"  # regular
-    _run "-_tcinsed_ml_zf" # regular with reset
-elif [[ "x$@" = "x-C" ]]; then
-    # codecgen
-    _run "-gx_tcinsed_ml" # codecgen: requires external
-    _run "-gxu_tcinsed_ml" # codecgen + unsafe
-elif [[ "x$@" = "x-X" ]]; then
-    # external
-    _run "-x_tcinsed_ml" # external
-elif [[ "x$@" = "x-h" || "x$@" = "x-?" ]]; then
-    cat <<EOF
-Usage: tests.sh [options...]
-  -A run through all tests (regular, external, codecgen)
-  -Z regular tests only 
-  -F regular tests only (without fastpath, so they run quickly)
-  -C codecgen only 
-  -X external only 
-  -h show help (usage)
-  -? same as -h
-  (no options) 
-      same as -A
-  (unrecognized options)
-      just pass on the options from the command line 
-EOF
-else
-    _run "$@"
-fi
diff --git a/vendor/github.com/ugorji/go/codec/time.go b/vendor/github.com/ugorji/go/codec/time.go
index 718b731ec58..55841d4cac6 100644
--- a/vendor/github.com/ugorji/go/codec/time.go
+++ b/vendor/github.com/ugorji/go/codec/time.go
@@ -5,23 +5,10 @@ package codec
 
 import (
 	"fmt"
-	"reflect"
 	"time"
 )
 
-var (
-	timeDigits   = [...]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
-	timeExtEncFn = func(rv reflect.Value) (bs []byte, err error) {
-		defer panicToErr(&err)
-		bs = timeExt{}.WriteExt(rv.Interface())
-		return
-	}
-	timeExtDecFn = func(rv reflect.Value, bs []byte) (err error) {
-		defer panicToErr(&err)
-		timeExt{}.ReadExt(rv.Interface(), bs)
-		return
-	}
-)
+var timeDigits = [...]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
 
 type timeExt struct{}
 
@@ -210,24 +197,24 @@ func decodeTime(bs []byte) (tt time.Time, err error) {
 	return
 }
 
-func timeLocUTCName(tzint int16) string {
-	if tzint == 0 {
-		return "UTC"
-	}
-	var tzname = []byte("UTC+00:00")
-	//tzname := fmt.Sprintf("UTC%s%02d:%02d", tzsign, tz/60, tz%60) //perf issue using Sprintf. inline below.
-	//tzhr, tzmin := tz/60, tz%60 //faster if u convert to int first
-	var tzhr, tzmin int16
-	if tzint < 0 {
-		tzname[3] = '-' // (TODO: verify. this works here)
-		tzhr, tzmin = -tzint/60, (-tzint)%60
-	} else {
-		tzhr, tzmin = tzint/60, tzint%60
-	}
-	tzname[4] = timeDigits[tzhr/10]
-	tzname[5] = timeDigits[tzhr%10]
-	tzname[7] = timeDigits[tzmin/10]
-	tzname[8] = timeDigits[tzmin%10]
-	return string(tzname)
-	//return time.FixedZone(string(tzname), int(tzint)*60)
-}
+// func timeLocUTCName(tzint int16) string {
+// 	if tzint == 0 {
+// 		return "UTC"
+// 	}
+// 	var tzname = []byte("UTC+00:00")
+// 	//tzname := fmt.Sprintf("UTC%s%02d:%02d", tzsign, tz/60, tz%60) //perf issue using Sprintf. inline below.
+// 	//tzhr, tzmin := tz/60, tz%60 //faster if u convert to int first
+// 	var tzhr, tzmin int16
+// 	if tzint < 0 {
+// 		tzname[3] = '-' // (TODO: verify. this works here)
+// 		tzhr, tzmin = -tzint/60, (-tzint)%60
+// 	} else {
+// 		tzhr, tzmin = tzint/60, tzint%60
+// 	}
+// 	tzname[4] = timeDigits[tzhr/10]
+// 	tzname[5] = timeDigits[tzhr%10]
+// 	tzname[7] = timeDigits[tzmin/10]
+// 	tzname[8] = timeDigits[tzmin%10]
+// 	return string(tzname)
+// 	//return time.FixedZone(string(tzname), int(tzint)*60)
+// }
diff --git a/vendor/github.com/ugorji/go/codec/xml.go b/vendor/github.com/ugorji/go/codec/xml.go
new file mode 100644
index 00000000000..9386775d760
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/xml.go
@@ -0,0 +1,426 @@
+// +build ignore
+
+package codec
+
+import "reflect"
+
+/*
+
+A strict Non-validating namespace-aware XML 1.0 parser and (en|de)coder.
+
+We are attempting this due to perceived issues with encoding/xml:
+  - Complicated. It tried to do too much, and is not as simple to use as json.
+  - Due to over-engineering, reflection is over-used AND performance suffers:
+    java is 6X faster:http://fabsk.eu/blog/category/informatique/dev/golang/
+    even PYTHON performs better: http://outgoing.typepad.com/outgoing/2014/07/exploring-golang.html
+
+codec framework will offer the following benefits
+  - VASTLY improved performance (when using reflection-mode or codecgen)
+  - simplicity and consistency: with the rest of the supported formats
+  - all other benefits of codec framework (streaming, codegeneration, etc)
+
+codec is not a drop-in replacement for encoding/xml.
+It is a replacement, based on the simplicity and performance of codec.
+Look at it like JAXB for Go.
+
+Challenges:
+
+  - Need to output XML preamble, with all namespaces at the right location in the output.
+  - Each "end" block is dynamic, so we need to maintain a context-aware stack
+  - How to decide when to use an attribute VS an element
+  - How to handle chardata, attr, comment EXPLICITLY.
+  - Should it output fragments?
+    e.g. encoding a bool should just output true OR false, which is not well-formed XML.
+
+Extend the struct tag. See representative example:
+  type X struct {
+    ID uint8 codec:"xid|http://ugorji.net/x-namespace id,omitempty,toarray,attr,cdata"
+  }
+
+Based on this, we encode
+  - fields as elements, BUT encode as attributes if struct tag contains ",attr".
+  - text as entity-escaped text, BUT encode as CDATA if struct tag contains ",cdata".
+
+In this mode, we only encode as attribute if ",attr" is found, and only encode as CDATA
+if ",cdata" is found in the struct tag.
+
+To handle namespaces:
+  - XMLHandle is denoted as being namespace-aware.
+    Consequently, we WILL use the ns:name pair to encode and decode if defined, else use the plain name.
+  - *Encoder and *Decoder know whether the Handle "prefers" namespaces.
+  - add *Encoder.getEncName(*structFieldInfo).
+    No one calls *structFieldInfo.indexForEncName directly anymore
+  - add *Decoder.getStructFieldInfo(encName string) // encName here is either like abc, or h1:nsabc
+    No one accesses .encName anymore except in
+  - let encode.go and decode.go use these (for consistency)
+  - only problem exists for gen.go, where we create a big switch on encName.
+    Now, we also have to add a switch on strings.endsWith(kName, encNsName)
+    - gen.go will need to have many more methods, and then double-on the 2 switch loops like:
+      switch k {
+        case "abc" : x.abc()
+        case "def" : x.def()
+        default {
+          switch {
+            case !nsAware: panic(...)
+            case strings.endsWith("nsabc"): x.abc()
+            default: panic(...)
+          }
+        }
+     }
+
+The structure below accomodates this:
+
+  type typeInfo struct {
+    sfi []*structFieldInfo // sorted by encName
+    sfins // sorted by namespace
+    sfia  // sorted, to have those with attributes at the top. Needed to write XML appropriately.
+    sfip  // unsorted
+  }
+  type structFieldInfo struct {
+    encName
+    nsEncName
+    ns string
+    attr bool
+    cdata bool
+  }
+
+indexForEncName is now an internal helper function that takes a sorted array
+(one of ti.sfins or ti.sfi). It is only used by *Encoder.getStructFieldInfo(...)
+
+There will be a separate parser from the builder.
+The parser will have a method: next() xmlToken method.
+
+xmlToken has fields:
+  - type uint8: 0 | ElementStart | ElementEnd | AttrKey | AttrVal | Text
+  - value string
+  - ns string
+
+SEE: http://www.xml.com/pub/a/98/10/guide0.html?page=3#ENTDECL
+
+The following are skipped when parsing:
+  - External Entities (from external file)
+  - Notation Declaration e.g. <!NOTATION GIF87A SYSTEM "GIF">
+  - Entity Declarations & References
+  - XML Declaration (assume UTF-8)
+  - XML Directive i.e. <! ... >
+  - Other Declarations: Notation, etc.
+  - Comment
+  - Processing Instruction
+  - schema / DTD for validation:
+    We are not a VALIDATING parser. Validation is done elsewhere.
+    However, some parts of the DTD internal subset are used (SEE BELOW).
+    For Attribute List Declarations e.g.
+    <!ATTLIST foo:oldjoke name ID #REQUIRED label CDATA #IMPLIED status ( funny | notfunny ) 'funny' >
+    We considered using the ATTLIST to get "default" value, but not to validate the contents. (VETOED)
+
+The following XML features are supported
+  - Namespace
+  - Element
+  - Attribute
+  - cdata
+  - Unicode escape
+
+The following DTD (when as an internal sub-set) features are supported:
+  - Internal Entities e.g.
+    <!ELEMENT burns "ugorji is cool" > AND entities for the set: [<>&"']
+  - Parameter entities e.g.
+    <!ENTITY % personcontent "ugorji is cool"> <!ELEMENT burns (%personcontent;)*>
+
+At decode time, a structure containing the following is kept
+  - namespace mapping
+  - default attribute values
+  - all internal entities (<>&"' and others written in the document)
+
+When decode starts, it parses XML namespace declarations and creates a map in the
+xmlDecDriver. While parsing, that map continously gets updated.
+The only problem happens when a namespace declaration happens on the node that it defines.
+e.g. <hn:name xmlns:hn="http://www.ugorji.net" >
+To handle this, each Element must be fully parsed at a time,
+even if it amounts to multiple tokens which are returned one at a time on request.
+
+xmlns is a special attribute name.
+  - It is used to define namespaces, including the default
+  - It is never returned as an AttrKey or AttrVal.
+  *We may decide later to allow user to use it e.g. you want to parse the xmlns mappings into a field.*
+
+Number, bool, null, mapKey, etc can all be decoded from any xmlToken.
+This accomodates map[int]string for example.
+
+It should be possible to create a schema from the types,
+or vice versa (generate types from schema with appropriate tags).
+This is however out-of-scope from this parsing project.
+
+We should write all namespace information at the first point that it is referenced in the tree,
+and use the mapping for all child nodes and attributes. This means that state is maintained
+at a point in the tree. This also means that calls to Decode or MustDecode will reset some state.
+
+When decoding, it is important to keep track of entity references and default attribute values.
+It seems these can only be stored in the DTD components. We should honor them when decoding.
+
+Configuration for XMLHandle will look like this:
+
+  XMLHandle
+    DefaultNS string
+    // Encoding:
+    NS map[string]string // ns URI to key, used for encoding
+    // Decoding: in case ENTITY declared in external schema or dtd, store info needed here
+    Entities map[string]string // map of entity rep to character
+
+
+During encode, if a namespace mapping is not defined for a namespace found on a struct,
+then we create a mapping for it using nsN (where N is 1..1000000, and doesn't conflict
+with any other namespace mapping).
+
+Note that different fields in a struct can have different namespaces.
+However, all fields will default to the namespace on the _struct field (if defined).
+
+An XML document is a name, a map of attributes and a list of children.
+Consequently, we cannot "DecodeNaked" into a map[string]interface{} (for example).
+We have to "DecodeNaked" into something that resembles XML data.
+
+To support DecodeNaked (decode into nil interface{}) we have to define some "supporting" types:
+    type Name struct { // Prefered. Less allocations due to conversions.
+      Local string
+      Space string
+    }
+    type Element struct {
+      Name Name
+      Attrs map[Name]string
+      Children []interface{} // each child is either *Element or string
+    }
+Only two "supporting" types are exposed for XML: Name and Element.
+
+We considered 'type Name string' where Name is like "Space Local" (space-separated).
+We decided against it, because each creation of a name would lead to
+double allocation (first convert []byte to string, then concatenate them into a string).
+The benefit is that it is faster to read Attrs from a map. But given that Element is a value
+object, we want to eschew methods and have public exposed variables.
+
+We also considered the following, where xml types were not value objects, and we used
+intelligent accessor methods to extract information and for performance.
+*** WE DECIDED AGAINST THIS. ***
+    type Attr struct {
+      Name Name
+      Value string
+    }
+    // Element is a ValueObject: There are no accessor methods.
+    // Make element self-contained.
+    type Element struct {
+      Name Name
+      attrsMap map[string]string // where key is "Space Local"
+      attrs []Attr
+      childrenT []string
+      childrenE []Element
+      childrenI []int // each child is a index into T or E.
+    }
+    func (x *Element) child(i) interface{} // returns string or *Element
+
+Per XML spec and our default handling, white space is insignificant between elements,
+specifically between parent-child or siblings. White space occuring alone between start
+and end element IS significant. However, if xml:space='preserve', then we 'preserve'
+all whitespace. This is more critical when doing a DecodeNaked, but MAY not be as critical
+when decoding into a typed value.
+
+**Note: there is no xml: namespace. The xml: attributes were defined before namespaces.**
+**So treat them as just "directives" that should be interpreted to mean something**.
+
+On encoding, we don't add any prettifying markup (indenting, etc).
+
+A document or element can only be encoded/decoded from/to a struct. In this mode:
+  - struct name maps to element name (or tag-info from _struct field)
+  - fields are mapped to child elements or attributes
+
+A map is either encoded as attributes on current element, or as a set of child elements.
+Maps are encoded as attributes iff their keys and values are primitives (number, bool, string).
+
+A list is encoded as a set of child elements.
+
+Primitives (number, bool, string) are encoded as an element, attribute or text
+depending on the context.
+
+Extensions must encode themselves as a text string.
+
+Encoding is tough, specifically when encoding mappings, because we need to encode
+as either attribute or element. To do this, we need to default to encoding as attributes,
+and then let Encoder inform the Handle when to start encoding as nodes.
+i.e. Encoder does something like:
+
+    h.EncodeMapStart()
+    h.Encode(), h.Encode(), ...
+    h.EncodeMapNotAttrSignal() // this is not a bool, because it's a signal
+    h.Encode(), h.Encode(), ...
+    h.EncodeEnd()
+
+Only XMLHandle understands this, and will set itself to start encoding as elements.
+
+This support extends to maps. For example, if a struct field is a map, and it has
+the struct tag signifying it should be attr, then all its fields are encoded as attributes.
+e.g.
+
+    type X struct {
+       M map[string]int `codec:"m,attr"` // encode as attributes
+    }
+
+Question:
+  - if encoding a map, what if map keys have spaces in them???
+    Then they cannot be attributes or child elements. Error.
+
+Misc:
+
+  - For attribute values, normalize by trimming beginning and ending white space,
+    and converting every white space sequence to a single space.
+  - ATTLIST restrictions are enforced.
+    e.g. default value of xml:space, skipping xml:XYZ style attributes, etc.
+  - Consider supporting NON-STRICT mode (e.g. to handle HTML parsing).
+    Some elements e.g. br, hr, etc need not close and should be auto-closed
+    ... (see http://www.w3.org/TR/html4/loose.dtd)
+    An expansive set of entities are pre-defined.
+  - Have easy way to create a HTML parser:
+    add a HTML() method to XMLHandle, that will set Strict=false, specify AutoClose,
+    and add HTML Entities to the list.
+  - Support validating element/attribute XMLName before writing it.
+    Keep this behind a flag, which is set to false by default (for performance).
+    type XMLHandle struct {
+      CheckName bool
+    }
+
+ROADMAP (1 weeks):
+  - build encoder (1 day)
+  - build decoder (based off xmlParser) (1 day)
+  - implement xmlParser (2 days).
+    Look at encoding/xml for inspiration.
+  - integrate and TEST (1 days)
+  - write article and post it (1 day)
+
+
+*/
+
+// ----------- PARSER  -------------------
+
+type xmlTokenType uint8
+
+const (
+	_ xmlTokenType = iota << 1
+	xmlTokenElemStart
+	xmlTokenElemEnd
+	xmlTokenAttrKey
+	xmlTokenAttrVal
+	xmlTokenText
+)
+
+type xmlToken struct {
+	Type      xmlTokenType
+	Value     string
+	Namespace string // blank for AttrVal and Text
+}
+
+type xmlParser struct {
+	r    decReader
+	toks []xmlToken // list of tokens.
+	ptr  int        // ptr into the toks slice
+	done bool       // nothing else to parse. r now returns EOF.
+}
+
+func (x *xmlParser) next() (t *xmlToken) {
+	// once x.done, or x.ptr == len(x.toks) == 0, then return nil (to signify finish)
+	if !x.done && len(x.toks) == 0 {
+		x.nextTag()
+	}
+	// parses one element at a time (into possible many tokens)
+	if x.ptr < len(x.toks) {
+		t = &(x.toks[x.ptr])
+		x.ptr++
+		if x.ptr == len(x.toks) {
+			x.ptr = 0
+			x.toks = x.toks[:0]
+		}
+	}
+	return
+}
+
+// nextTag will parses the next element and fill up toks.
+// It set done flag if/once EOF is reached.
+func (x *xmlParser) nextTag() {
+	// TODO: implement.
+}
+
+// ----------- ENCODER -------------------
+
+type xmlEncDriver struct {
+	e  *Encoder
+	w  encWriter
+	h  *XMLHandle
+	b  [64]byte // scratch
+	bs []byte   // scratch
+	// s  jsonStack
+	noBuiltInTypes
+}
+
+// ----------- DECODER -------------------
+
+type xmlDecDriver struct {
+	d    *Decoder
+	h    *XMLHandle
+	r    decReader // *bytesDecReader decReader
+	ct   valueType // container type. one of unset, array or map.
+	bstr [8]byte   // scratch used for string \UXXX parsing
+	b    [64]byte  // scratch
+
+	// wsSkipped bool // whitespace skipped
+
+	// s jsonStack
+
+	noBuiltInTypes
+}
+
+// DecodeNaked will decode into an XMLNode
+
+// XMLName is a value object representing a namespace-aware NAME
+type XMLName struct {
+	Local string
+	Space string
+}
+
+// XMLNode represents a "union" of the different types of XML Nodes.
+// Only one of fields (Text or *Element) is set.
+type XMLNode struct {
+	Element *Element
+	Text    string
+}
+
+// XMLElement is a value object representing an fully-parsed XML element.
+type XMLElement struct {
+	Name  Name
+	Attrs map[XMLName]string
+	// Children is a list of child nodes, each being a *XMLElement or string
+	Children []XMLNode
+}
+
+// ----------- HANDLE  -------------------
+
+type XMLHandle struct {
+	BasicHandle
+	textEncodingType
+
+	DefaultNS string
+	NS        map[string]string // ns URI to key, for encoding
+	Entities  map[string]string // entity representation to string, for encoding.
+}
+
+func (h *XMLHandle) newEncDriver(e *Encoder) encDriver {
+	return &xmlEncDriver{e: e, w: e.w, h: h}
+}
+
+func (h *XMLHandle) newDecDriver(d *Decoder) decDriver {
+	// d := xmlDecDriver{r: r.(*bytesDecReader), h: h}
+	hd := xmlDecDriver{d: d, r: d.r, h: h}
+	hd.n.bytes = d.b[:]
+	return &hd
+}
+
+func (h *XMLHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
+	return h.SetExt(rt, tag, &setExtWrapper{i: ext})
+}
+
+var _ decDriver = (*xmlDecDriver)(nil)
+var _ encDriver = (*xmlEncDriver)(nil)
diff --git a/vendor/github.com/ugorji/go/codec/z.go b/vendor/github.com/ugorji/go/codec/z.go
new file mode 100644
index 00000000000..b6ac0769a05
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/z.go
@@ -0,0 +1,23 @@
+// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+import "sort"
+
+// TODO: this is brittle, as it depends on z.go's init() being called last.
+// The current build tools all honor that files are passed in lexical order.
+// However, we should consider using an init_channel,
+// that each person doing init will write to.
+
+func init() {
+	if !useLookupRecognizedTypes {
+		return
+	}
+	sort.Sort(uintptrSlice(recognizedRtids))
+	sort.Sort(uintptrSlice(recognizedRtidPtrs))
+	recognizedRtidOrPtrs = make([]uintptr, len(recognizedRtids)+len(recognizedRtidPtrs))
+	copy(recognizedRtidOrPtrs, recognizedRtids)
+	copy(recognizedRtidOrPtrs[len(recognizedRtids):], recognizedRtidPtrs)
+	sort.Sort(uintptrSlice(recognizedRtidOrPtrs))
+}
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go
deleted file mode 100644
index 53d57f67a53..00000000000
--- a/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/api/annotations.proto
-
-/*
-Package annotations is a generated protocol buffer package.
-
-It is generated from these files:
-	google/api/annotations.proto
-	google/api/http.proto
-
-It has these top-level messages:
-	Http
-	HttpRule
-	CustomHttpPattern
-*/
-package annotations
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-var E_Http = &proto.ExtensionDesc{
-	ExtendedType:  (*google_protobuf.MethodOptions)(nil),
-	ExtensionType: (*HttpRule)(nil),
-	Field:         72295728,
-	Name:          "google.api.http",
-	Tag:           "bytes,72295728,opt,name=http",
-	Filename:      "google/api/annotations.proto",
-}
-
-func init() {
-	proto.RegisterExtension(E_Http)
-}
-
-func init() { proto.RegisterFile("google/api/annotations.proto", fileDescriptor0) }
-
-var fileDescriptor0 = []byte{
-	// 208 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x49, 0xcf, 0xcf, 0x4f,
-	0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xcc, 0xcb, 0xcb, 0x2f, 0x49, 0x2c, 0xc9, 0xcc,
-	0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x82, 0xc8, 0xea, 0x25, 0x16, 0x64,
-	0x4a, 0x89, 0x22, 0xa9, 0xcc, 0x28, 0x29, 0x29, 0x80, 0x28, 0x91, 0x52, 0x80, 0x0a, 0x83, 0x79,
-	0x49, 0xa5, 0x69, 0xfa, 0x29, 0xa9, 0xc5, 0xc9, 0x45, 0x99, 0x05, 0x25, 0xf9, 0x45, 0x10, 0x15,
-	0x56, 0xde, 0x5c, 0x2c, 0x20, 0xf5, 0x42, 0x72, 0x7a, 0x50, 0xd3, 0x60, 0x4a, 0xf5, 0x7c, 0x53,
-	0x4b, 0x32, 0xf2, 0x53, 0xfc, 0x0b, 0xc0, 0x56, 0x4a, 0x6c, 0x38, 0xb5, 0x47, 0x49, 0x81, 0x51,
-	0x83, 0xdb, 0x48, 0x44, 0x0f, 0x61, 0xad, 0x9e, 0x47, 0x49, 0x49, 0x41, 0x50, 0x69, 0x4e, 0x6a,
-	0x10, 0xd8, 0x10, 0xa7, 0x3c, 0x2e, 0xbe, 0xe4, 0xfc, 0x5c, 0x24, 0x05, 0x4e, 0x02, 0x8e, 0x08,
-	0x67, 0x07, 0x80, 0x4c, 0x0e, 0x60, 0x8c, 0x72, 0x84, 0xca, 0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5,
-	0xeb, 0xe5, 0x17, 0xa5, 0xeb, 0xa7, 0xa7, 0xe6, 0x81, 0xed, 0xd5, 0x87, 0x48, 0x25, 0x16, 0x64,
-	0x16, 0xa3, 0x7b, 0xda, 0x1a, 0x89, 0xbd, 0x88, 0x89, 0xc5, 0xdd, 0x31, 0xc0, 0x33, 0x89, 0x0d,
-	0xac, 0xc9, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x29, 0x19, 0x62, 0x28, 0x01, 0x00, 0x00,
-}
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go
deleted file mode 100644
index f91c604620b..00000000000
--- a/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go
+++ /dev/null
@@ -1,566 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/api/http.proto
-
-package annotations
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// Defines the HTTP configuration for a service. It contains a list of
-// [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method
-// to one or more HTTP REST API methods.
-type Http struct {
-	// A list of HTTP configuration rules that apply to individual API methods.
-	//
-	// **NOTE:** All service configuration rules follow "last one wins" order.
-	Rules []*HttpRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
-}
-
-func (m *Http) Reset()                    { *m = Http{} }
-func (m *Http) String() string            { return proto.CompactTextString(m) }
-func (*Http) ProtoMessage()               {}
-func (*Http) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
-
-func (m *Http) GetRules() []*HttpRule {
-	if m != nil {
-		return m.Rules
-	}
-	return nil
-}
-
-// `HttpRule` defines the mapping of an RPC method to one or more HTTP
-// REST APIs.  The mapping determines what portions of the request
-// message are populated from the path, query parameters, or body of
-// the HTTP request.  The mapping is typically specified as an
-// `google.api.http` annotation, see "google/api/annotations.proto"
-// for details.
-//
-// The mapping consists of a field specifying the path template and
-// method kind.  The path template can refer to fields in the request
-// message, as in the example below which describes a REST GET
-// operation on a resource collection of messages:
-//
-//
-//     service Messaging {
-//       rpc GetMessage(GetMessageRequest) returns (Message) {
-//         option (google.api.http).get = "/v1/messages/{message_id}/{sub.subfield}";
-//       }
-//     }
-//     message GetMessageRequest {
-//       message SubMessage {
-//         string subfield = 1;
-//       }
-//       string message_id = 1; // mapped to the URL
-//       SubMessage sub = 2;    // `sub.subfield` is url-mapped
-//     }
-//     message Message {
-//       string text = 1; // content of the resource
-//     }
-//
-// The same http annotation can alternatively be expressed inside the
-// `GRPC API Configuration` YAML file.
-//
-//     http:
-//       rules:
-//         - selector: <proto_package_name>.Messaging.GetMessage
-//           get: /v1/messages/{message_id}/{sub.subfield}
-//
-// This definition enables an automatic, bidrectional mapping of HTTP
-// JSON to RPC. Example:
-//
-// HTTP | RPC
-// -----|-----
-// `GET /v1/messages/123456/foo`  | `GetMessage(message_id: "123456" sub: SubMessage(subfield: "foo"))`
-//
-// In general, not only fields but also field paths can be referenced
-// from a path pattern. Fields mapped to the path pattern cannot be
-// repeated and must have a primitive (non-message) type.
-//
-// Any fields in the request message which are not bound by the path
-// pattern automatically become (optional) HTTP query
-// parameters. Assume the following definition of the request message:
-//
-//
-//     message GetMessageRequest {
-//       message SubMessage {
-//         string subfield = 1;
-//       }
-//       string message_id = 1; // mapped to the URL
-//       int64 revision = 2;    // becomes a parameter
-//       SubMessage sub = 3;    // `sub.subfield` becomes a parameter
-//     }
-//
-//
-// This enables a HTTP JSON to RPC mapping as below:
-//
-// HTTP | RPC
-// -----|-----
-// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: "foo"))`
-//
-// Note that fields which are mapped to HTTP parameters must have a
-// primitive type or a repeated primitive type. Message types are not
-// allowed. In the case of a repeated type, the parameter can be
-// repeated in the URL, as in `...?param=A&param=B`.
-//
-// For HTTP method kinds which allow a request body, the `body` field
-// specifies the mapping. Consider a REST update method on the
-// message resource collection:
-//
-//
-//     service Messaging {
-//       rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
-//         option (google.api.http) = {
-//           put: "/v1/messages/{message_id}"
-//           body: "message"
-//         };
-//       }
-//     }
-//     message UpdateMessageRequest {
-//       string message_id = 1; // mapped to the URL
-//       Message message = 2;   // mapped to the body
-//     }
-//
-//
-// The following HTTP JSON to RPC mapping is enabled, where the
-// representation of the JSON in the request body is determined by
-// protos JSON encoding:
-//
-// HTTP | RPC
-// -----|-----
-// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" message { text: "Hi!" })`
-//
-// The special name `*` can be used in the body mapping to define that
-// every field not bound by the path template should be mapped to the
-// request body.  This enables the following alternative definition of
-// the update method:
-//
-//     service Messaging {
-//       rpc UpdateMessage(Message) returns (Message) {
-//         option (google.api.http) = {
-//           put: "/v1/messages/{message_id}"
-//           body: "*"
-//         };
-//       }
-//     }
-//     message Message {
-//       string message_id = 1;
-//       string text = 2;
-//     }
-//
-//
-// The following HTTP JSON to RPC mapping is enabled:
-//
-// HTTP | RPC
-// -----|-----
-// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" text: "Hi!")`
-//
-// Note that when using `*` in the body mapping, it is not possible to
-// have HTTP parameters, as all fields not bound by the path end in
-// the body. This makes this option more rarely used in practice of
-// defining REST APIs. The common usage of `*` is in custom methods
-// which don't use the URL at all for transferring data.
-//
-// It is possible to define multiple HTTP methods for one RPC by using
-// the `additional_bindings` option. Example:
-//
-//     service Messaging {
-//       rpc GetMessage(GetMessageRequest) returns (Message) {
-//         option (google.api.http) = {
-//           get: "/v1/messages/{message_id}"
-//           additional_bindings {
-//             get: "/v1/users/{user_id}/messages/{message_id}"
-//           }
-//         };
-//       }
-//     }
-//     message GetMessageRequest {
-//       string message_id = 1;
-//       string user_id = 2;
-//     }
-//
-//
-// This enables the following two alternative HTTP JSON to RPC
-// mappings:
-//
-// HTTP | RPC
-// -----|-----
-// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")`
-// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: "123456")`
-//
-// # Rules for HTTP mapping
-//
-// The rules for mapping HTTP path, query parameters, and body fields
-// to the request message are as follows:
-//
-// 1. The `body` field specifies either `*` or a field path, or is
-//    omitted. If omitted, it assumes there is no HTTP body.
-// 2. Leaf fields (recursive expansion of nested messages in the
-//    request) can be classified into three types:
-//     (a) Matched in the URL template.
-//     (b) Covered by body (if body is `*`, everything except (a) fields;
-//         else everything under the body field)
-//     (c) All other fields.
-// 3. URL query parameters found in the HTTP request are mapped to (c) fields.
-// 4. Any body sent with an HTTP request can contain only (b) fields.
-//
-// The syntax of the path template is as follows:
-//
-//     Template = "/" Segments [ Verb ] ;
-//     Segments = Segment { "/" Segment } ;
-//     Segment  = "*" | "**" | LITERAL | Variable ;
-//     Variable = "{" FieldPath [ "=" Segments ] "}" ;
-//     FieldPath = IDENT { "." IDENT } ;
-//     Verb     = ":" LITERAL ;
-//
-// The syntax `*` matches a single path segment. It follows the semantics of
-// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String
-// Expansion.
-//
-// The syntax `**` matches zero or more path segments. It follows the semantics
-// of [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.3 Reserved
-// Expansion. NOTE: it must be the last segment in the path except the Verb.
-//
-// The syntax `LITERAL` matches literal text in the URL path.
-//
-// The syntax `Variable` matches the entire path as specified by its template;
-// this nested template must not contain further variables. If a variable
-// matches a single path segment, its template may be omitted, e.g. `{var}`
-// is equivalent to `{var=*}`.
-//
-// NOTE: the field paths in variables and in the `body` must not refer to
-// repeated fields or map fields.
-//
-// Use CustomHttpPattern to specify any HTTP method that is not included in the
-// `pattern` field, such as HEAD, or "*" to leave the HTTP method unspecified for
-// a given URL path rule. The wild-card rule is useful for services that provide
-// content to Web (HTML) clients.
-type HttpRule struct {
-	// Selects methods to which this rule applies.
-	//
-	// Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
-	Selector string `protobuf:"bytes,1,opt,name=selector" json:"selector,omitempty"`
-	// Determines the URL pattern is matched by this rules. This pattern can be
-	// used with any of the {get|put|post|delete|patch} methods. A custom method
-	// can be defined using the 'custom' field.
-	//
-	// Types that are valid to be assigned to Pattern:
-	//	*HttpRule_Get
-	//	*HttpRule_Put
-	//	*HttpRule_Post
-	//	*HttpRule_Delete
-	//	*HttpRule_Patch
-	//	*HttpRule_Custom
-	Pattern isHttpRule_Pattern `protobuf_oneof:"pattern"`
-	// The name of the request field whose value is mapped to the HTTP body, or
-	// `*` for mapping all fields not captured by the path pattern to the HTTP
-	// body. NOTE: the referred field must not be a repeated field and must be
-	// present at the top-level of request message type.
-	Body string `protobuf:"bytes,7,opt,name=body" json:"body,omitempty"`
-	// Additional HTTP bindings for the selector. Nested bindings must
-	// not contain an `additional_bindings` field themselves (that is,
-	// the nesting may only be one level deep).
-	AdditionalBindings []*HttpRule `protobuf:"bytes,11,rep,name=additional_bindings,json=additionalBindings" json:"additional_bindings,omitempty"`
-}
-
-func (m *HttpRule) Reset()                    { *m = HttpRule{} }
-func (m *HttpRule) String() string            { return proto.CompactTextString(m) }
-func (*HttpRule) ProtoMessage()               {}
-func (*HttpRule) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
-
-type isHttpRule_Pattern interface {
-	isHttpRule_Pattern()
-}
-
-type HttpRule_Get struct {
-	Get string `protobuf:"bytes,2,opt,name=get,oneof"`
-}
-type HttpRule_Put struct {
-	Put string `protobuf:"bytes,3,opt,name=put,oneof"`
-}
-type HttpRule_Post struct {
-	Post string `protobuf:"bytes,4,opt,name=post,oneof"`
-}
-type HttpRule_Delete struct {
-	Delete string `protobuf:"bytes,5,opt,name=delete,oneof"`
-}
-type HttpRule_Patch struct {
-	Patch string `protobuf:"bytes,6,opt,name=patch,oneof"`
-}
-type HttpRule_Custom struct {
-	Custom *CustomHttpPattern `protobuf:"bytes,8,opt,name=custom,oneof"`
-}
-
-func (*HttpRule_Get) isHttpRule_Pattern()    {}
-func (*HttpRule_Put) isHttpRule_Pattern()    {}
-func (*HttpRule_Post) isHttpRule_Pattern()   {}
-func (*HttpRule_Delete) isHttpRule_Pattern() {}
-func (*HttpRule_Patch) isHttpRule_Pattern()  {}
-func (*HttpRule_Custom) isHttpRule_Pattern() {}
-
-func (m *HttpRule) GetPattern() isHttpRule_Pattern {
-	if m != nil {
-		return m.Pattern
-	}
-	return nil
-}
-
-func (m *HttpRule) GetSelector() string {
-	if m != nil {
-		return m.Selector
-	}
-	return ""
-}
-
-func (m *HttpRule) GetGet() string {
-	if x, ok := m.GetPattern().(*HttpRule_Get); ok {
-		return x.Get
-	}
-	return ""
-}
-
-func (m *HttpRule) GetPut() string {
-	if x, ok := m.GetPattern().(*HttpRule_Put); ok {
-		return x.Put
-	}
-	return ""
-}
-
-func (m *HttpRule) GetPost() string {
-	if x, ok := m.GetPattern().(*HttpRule_Post); ok {
-		return x.Post
-	}
-	return ""
-}
-
-func (m *HttpRule) GetDelete() string {
-	if x, ok := m.GetPattern().(*HttpRule_Delete); ok {
-		return x.Delete
-	}
-	return ""
-}
-
-func (m *HttpRule) GetPatch() string {
-	if x, ok := m.GetPattern().(*HttpRule_Patch); ok {
-		return x.Patch
-	}
-	return ""
-}
-
-func (m *HttpRule) GetCustom() *CustomHttpPattern {
-	if x, ok := m.GetPattern().(*HttpRule_Custom); ok {
-		return x.Custom
-	}
-	return nil
-}
-
-func (m *HttpRule) GetBody() string {
-	if m != nil {
-		return m.Body
-	}
-	return ""
-}
-
-func (m *HttpRule) GetAdditionalBindings() []*HttpRule {
-	if m != nil {
-		return m.AdditionalBindings
-	}
-	return nil
-}
-
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*HttpRule) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _HttpRule_OneofMarshaler, _HttpRule_OneofUnmarshaler, _HttpRule_OneofSizer, []interface{}{
-		(*HttpRule_Get)(nil),
-		(*HttpRule_Put)(nil),
-		(*HttpRule_Post)(nil),
-		(*HttpRule_Delete)(nil),
-		(*HttpRule_Patch)(nil),
-		(*HttpRule_Custom)(nil),
-	}
-}
-
-func _HttpRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*HttpRule)
-	// pattern
-	switch x := m.Pattern.(type) {
-	case *HttpRule_Get:
-		b.EncodeVarint(2<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Get)
-	case *HttpRule_Put:
-		b.EncodeVarint(3<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Put)
-	case *HttpRule_Post:
-		b.EncodeVarint(4<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Post)
-	case *HttpRule_Delete:
-		b.EncodeVarint(5<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Delete)
-	case *HttpRule_Patch:
-		b.EncodeVarint(6<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Patch)
-	case *HttpRule_Custom:
-		b.EncodeVarint(8<<3 | proto.WireBytes)
-		if err := b.EncodeMessage(x.Custom); err != nil {
-			return err
-		}
-	case nil:
-	default:
-		return fmt.Errorf("HttpRule.Pattern has unexpected type %T", x)
-	}
-	return nil
-}
-
-func _HttpRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*HttpRule)
-	switch tag {
-	case 2: // pattern.get
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Pattern = &HttpRule_Get{x}
-		return true, err
-	case 3: // pattern.put
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Pattern = &HttpRule_Put{x}
-		return true, err
-	case 4: // pattern.post
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Pattern = &HttpRule_Post{x}
-		return true, err
-	case 5: // pattern.delete
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Pattern = &HttpRule_Delete{x}
-		return true, err
-	case 6: // pattern.patch
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Pattern = &HttpRule_Patch{x}
-		return true, err
-	case 8: // pattern.custom
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		msg := new(CustomHttpPattern)
-		err := b.DecodeMessage(msg)
-		m.Pattern = &HttpRule_Custom{msg}
-		return true, err
-	default:
-		return false, nil
-	}
-}
-
-func _HttpRule_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*HttpRule)
-	// pattern
-	switch x := m.Pattern.(type) {
-	case *HttpRule_Get:
-		n += proto.SizeVarint(2<<3 | proto.WireBytes)
-		n += proto.SizeVarint(uint64(len(x.Get)))
-		n += len(x.Get)
-	case *HttpRule_Put:
-		n += proto.SizeVarint(3<<3 | proto.WireBytes)
-		n += proto.SizeVarint(uint64(len(x.Put)))
-		n += len(x.Put)
-	case *HttpRule_Post:
-		n += proto.SizeVarint(4<<3 | proto.WireBytes)
-		n += proto.SizeVarint(uint64(len(x.Post)))
-		n += len(x.Post)
-	case *HttpRule_Delete:
-		n += proto.SizeVarint(5<<3 | proto.WireBytes)
-		n += proto.SizeVarint(uint64(len(x.Delete)))
-		n += len(x.Delete)
-	case *HttpRule_Patch:
-		n += proto.SizeVarint(6<<3 | proto.WireBytes)
-		n += proto.SizeVarint(uint64(len(x.Patch)))
-		n += len(x.Patch)
-	case *HttpRule_Custom:
-		s := proto.Size(x.Custom)
-		n += proto.SizeVarint(8<<3 | proto.WireBytes)
-		n += proto.SizeVarint(uint64(s))
-		n += s
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	return n
-}
-
-// A custom pattern is used for defining custom HTTP verb.
-type CustomHttpPattern struct {
-	// The name of this custom HTTP verb.
-	Kind string `protobuf:"bytes,1,opt,name=kind" json:"kind,omitempty"`
-	// The path matched by this custom verb.
-	Path string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
-}
-
-func (m *CustomHttpPattern) Reset()                    { *m = CustomHttpPattern{} }
-func (m *CustomHttpPattern) String() string            { return proto.CompactTextString(m) }
-func (*CustomHttpPattern) ProtoMessage()               {}
-func (*CustomHttpPattern) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
-
-func (m *CustomHttpPattern) GetKind() string {
-	if m != nil {
-		return m.Kind
-	}
-	return ""
-}
-
-func (m *CustomHttpPattern) GetPath() string {
-	if m != nil {
-		return m.Path
-	}
-	return ""
-}
-
-func init() {
-	proto.RegisterType((*Http)(nil), "google.api.Http")
-	proto.RegisterType((*HttpRule)(nil), "google.api.HttpRule")
-	proto.RegisterType((*CustomHttpPattern)(nil), "google.api.CustomHttpPattern")
-}
-
-func init() { proto.RegisterFile("google/api/http.proto", fileDescriptor1) }
-
-var fileDescriptor1 = []byte{
-	// 359 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xcf, 0x6a, 0xe3, 0x30,
-	0x10, 0xc6, 0xd7, 0x89, 0xe3, 0x24, 0x13, 0x58, 0x58, 0x6d, 0x76, 0x11, 0x85, 0x42, 0xc8, 0x29,
-	0xf4, 0x60, 0x43, 0x7a, 0xe8, 0x21, 0xa7, 0xb8, 0x94, 0xa6, 0xb7, 0xe0, 0x63, 0x2f, 0x45, 0xb1,
-	0x85, 0xa2, 0xd6, 0x91, 0x84, 0x3d, 0x3e, 0xf4, 0x75, 0xfa, 0x0e, 0x7d, 0xb7, 0x1e, 0x8b, 0xfe,
-	0xa4, 0x09, 0x14, 0x7a, 0x9b, 0xef, 0x37, 0x9f, 0x34, 0xa3, 0x19, 0xc1, 0x3f, 0xa1, 0xb5, 0xa8,
-	0x79, 0xc6, 0x8c, 0xcc, 0xf6, 0x88, 0x26, 0x35, 0x8d, 0x46, 0x4d, 0xc0, 0xe3, 0x94, 0x19, 0x39,
-	0x5f, 0x42, 0xbc, 0x41, 0x34, 0xe4, 0x0a, 0x06, 0x4d, 0x57, 0xf3, 0x96, 0x46, 0xb3, 0xfe, 0x62,
-	0xb2, 0x9c, 0xa6, 0x27, 0x4f, 0x6a, 0x0d, 0x45, 0x57, 0xf3, 0xc2, 0x5b, 0xe6, 0xef, 0x3d, 0x18,
-	0x1d, 0x19, 0xb9, 0x80, 0x51, 0xcb, 0x6b, 0x5e, 0xa2, 0x6e, 0x68, 0x34, 0x8b, 0x16, 0xe3, 0xe2,
-	0x4b, 0x13, 0x02, 0x7d, 0xc1, 0x91, 0xf6, 0x2c, 0xde, 0xfc, 0x2a, 0xac, 0xb0, 0xcc, 0x74, 0x48,
-	0xfb, 0x47, 0x66, 0x3a, 0x24, 0x53, 0x88, 0x8d, 0x6e, 0x91, 0xc6, 0x01, 0x3a, 0x45, 0x28, 0x24,
-	0x15, 0xaf, 0x39, 0x72, 0x3a, 0x08, 0x3c, 0x68, 0xf2, 0x1f, 0x06, 0x86, 0x61, 0xb9, 0xa7, 0x49,
-	0x48, 0x78, 0x49, 0x6e, 0x20, 0x29, 0xbb, 0x16, 0xf5, 0x81, 0x8e, 0x66, 0xd1, 0x62, 0xb2, 0xbc,
-	0x3c, 0x7f, 0xc5, 0xad, 0xcb, 0xd8, 0xbe, 0xb7, 0x0c, 0x91, 0x37, 0xca, 0x5e, 0xe8, 0xed, 0x84,
-	0x40, 0xbc, 0xd3, 0xd5, 0x2b, 0x1d, 0xba, 0x07, 0xb8, 0x98, 0xdc, 0xc1, 0x5f, 0x56, 0x55, 0x12,
-	0xa5, 0x56, 0xac, 0x7e, 0xda, 0x49, 0x55, 0x49, 0x25, 0x5a, 0x3a, 0xf9, 0x61, 0x3e, 0xe4, 0x74,
-	0x20, 0x0f, 0xfe, 0x7c, 0x0c, 0x43, 0xe3, 0xeb, 0xcd, 0x57, 0xf0, 0xe7, 0x5b, 0x13, 0xb6, 0xf4,
-	0x8b, 0x54, 0x55, 0x98, 0x9d, 0x8b, 0x2d, 0x33, 0x0c, 0xf7, 0x7e, 0x70, 0x85, 0x8b, 0xf3, 0x67,
-	0xf8, 0x5d, 0xea, 0xc3, 0x59, 0xd9, 0x7c, 0xec, 0xae, 0xb1, 0x1b, 0xdd, 0x46, 0x8f, 0xeb, 0x90,
-	0x10, 0xba, 0x66, 0x4a, 0xa4, 0xba, 0x11, 0x99, 0xe0, 0xca, 0xed, 0x3b, 0xf3, 0x29, 0x66, 0x64,
-	0xeb, 0x7e, 0x02, 0x53, 0x4a, 0x23, 0xb3, 0x6d, 0xb6, 0xab, 0xb3, 0xf8, 0x23, 0x8a, 0xde, 0x7a,
-	0xf1, 0xfd, 0x7a, 0xfb, 0xb0, 0x4b, 0xdc, 0xb9, 0xeb, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x68,
-	0x15, 0x60, 0x5b, 0x40, 0x02, 0x00, 0x00,
-}
diff --git a/vendor/google.golang.org/grpc/BUILD b/vendor/google.golang.org/grpc/BUILD
index b453f90a9c9..286fe9409c4 100644
--- a/vendor/google.golang.org/grpc/BUILD
+++ b/vendor/google.golang.org/grpc/BUILD
@@ -66,7 +66,7 @@ filegroup(
         "//vendor/google.golang.org/grpc/credentials:all-srcs",
         "//vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/messages:all-srcs",
         "//vendor/google.golang.org/grpc/grpclog:all-srcs",
-        "//vendor/google.golang.org/grpc/health/grpc_health_v1:all-srcs",
+        "//vendor/google.golang.org/grpc/health:all-srcs",
         "//vendor/google.golang.org/grpc/internal:all-srcs",
         "//vendor/google.golang.org/grpc/keepalive:all-srcs",
         "//vendor/google.golang.org/grpc/metadata:all-srcs",
diff --git a/vendor/google.golang.org/grpc/health/BUILD b/vendor/google.golang.org/grpc/health/BUILD
new file mode 100644
index 00000000000..05caf6bf411
--- /dev/null
+++ b/vendor/google.golang.org/grpc/health/BUILD
@@ -0,0 +1,32 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["health.go"],
+    importmap = "k8s.io/kubernetes/vendor/google.golang.org/grpc/health",
+    importpath = "google.golang.org/grpc/health",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/golang.org/x/net/context:go_default_library",
+        "//vendor/google.golang.org/grpc:go_default_library",
+        "//vendor/google.golang.org/grpc/codes:go_default_library",
+        "//vendor/google.golang.org/grpc/health/grpc_health_v1:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//vendor/google.golang.org/grpc/health/grpc_health_v1:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
diff --git a/vendor/google.golang.org/grpc/health/health.go b/vendor/google.golang.org/grpc/health/health.go
new file mode 100644
index 00000000000..c6212f406f7
--- /dev/null
+++ b/vendor/google.golang.org/grpc/health/health.go
@@ -0,0 +1,72 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+//go:generate protoc --go_out=plugins=grpc:. grpc_health_v1/health.proto
+
+// Package health provides some utility functions to health-check a server. The implementation
+// is based on protobuf. Users need to write their own implementations if other IDLs are used.
+package health
+
+import (
+	"sync"
+
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	healthpb "google.golang.org/grpc/health/grpc_health_v1"
+)
+
+// Server implements `service Health`.
+type Server struct {
+	mu sync.Mutex
+	// statusMap stores the serving status of the services this Server monitors.
+	statusMap map[string]healthpb.HealthCheckResponse_ServingStatus
+}
+
+// NewServer returns a new Server.
+func NewServer() *Server {
+	return &Server{
+		statusMap: make(map[string]healthpb.HealthCheckResponse_ServingStatus),
+	}
+}
+
+// Check implements `service Health`.
+func (s *Server) Check(ctx context.Context, in *healthpb.HealthCheckRequest) (*healthpb.HealthCheckResponse, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if in.Service == "" {
+		// check the server overall health status.
+		return &healthpb.HealthCheckResponse{
+			Status: healthpb.HealthCheckResponse_SERVING,
+		}, nil
+	}
+	if status, ok := s.statusMap[in.Service]; ok {
+		return &healthpb.HealthCheckResponse{
+			Status: status,
+		}, nil
+	}
+	return nil, grpc.Errorf(codes.NotFound, "unknown service")
+}
+
+// SetServingStatus is called when need to reset the serving status of a service
+// or insert a new service entry into the statusMap.
+func (s *Server) SetServingStatus(service string, status healthpb.HealthCheckResponse_ServingStatus) {
+	s.mu.Lock()
+	s.statusMap[service] = status
+	s.mu.Unlock()
+}
diff --git a/vendordiff.patch b/vendordiff.patch
new file mode 100644
index 00000000000..a7201cbe9cd
--- /dev/null
+++ b/vendordiff.patch
@@ -0,0 +1,25 @@
+diff -Naupr -x BUILD -x 'AUTHORS*' -x 'CONTRIBUTORS*' vendor/k8s.io/apiserver/pkg/storage/etcd/testing/utils.go /tmp/gopath.qtqLRB/src/k8s.io/kubernetes/vendor/k8s.io/apiserver/pkg/storage/etcd/testing/utils.go
+--- vendor/k8s.io/apiserver/pkg/storage/etcd/testing/utils.go	2018-10-01 16:58:52.811248049 -0700
++++ /tmp/gopath.qtqLRB/src/k8s.io/kubernetes/vendor/k8s.io/apiserver/pkg/storage/etcd/testing/utils.go	2018-10-01 16:55:15.000000000 -0700
+@@ -189,7 +189,7 @@ func configureTestCluster(t *testing.T,
+ // launch will attempt to start the etcd server
+ func (m *EtcdTestServer) launch(t *testing.T) error {
+ 	var err error
+-	if m.s, err = etcdserver.NewServer(m.ServerConfig); err != nil {
++	if m.s, err = etcdserver.NewServer(&m.ServerConfig); err != nil {
+ 		return fmt.Errorf("failed to initialize the etcd server: %v", err)
+ 	}
+ 	m.s.SyncTicker = time.NewTicker(500 * time.Millisecond)
+@@ -297,7 +297,7 @@ func NewUnsecuredEtcd3TestClientServer(t
+ 		Prefix:                   etcdtest.PathPrefix(),
+ 		ServerList:               server.V3Client.Endpoints(),
+ 		DeserializationCacheSize: etcdtest.DeserializationCacheSize,
+-		Paging:                   true,
++		Paging: true,
+ 	}
+ 	return server, config
+ }
+Only in vendor/k8s.io/apiserver/pkg/storage/etcd3: 127.0.0.1:21001114727
+Only in vendor/k8s.io/apiserver/pkg/storage/etcd3: 127.0.0.1:21002114727
+Only in vendor/k8s.io/apiserver/pkg/storage/etcd3: localhost:7941259886567686464
+Only in vendor/k8s.io/apiserver/pkg/storage/etcd3: localhost:79412598865676864640